1
          
          class ApplicationController < ActionController::Base
        
      
        

          
          
          
        
      
        

          1
          
            helper :all # include all helpers, all the time
        
      
        

          
          
          
        
      
        

          1
          
            helper_method :current_user
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :make_available_for_exception_notification
        
      
        

          
          
          
        
      
        

          
          
            # See ActionController::RequestForgeryProtection for details
        
      
        

          
          
            # Uncomment the :secret if you're not using the cookie session store
        
      
        

          1
          
            protect_from_forgery # :secret => '5e9d164f3052749a36db7a972c72915a'
        
      
        

          
          
          
        
      
        

          
          
            # Return true if the user agent is a bot.
        
      
        

          1
          
            def robot?
        
      
        

          1
          
              bot = /(Baidu|bot|Google|SiteUptime|Slurp|WordPress|ZIBB|ZyBorg)/i
        
      
        

          1
          
              request.user_agent =~ bot
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def get_http_referer
        
      
        

          
          
              if request.env["HTTP_REFERER"].nil? then
        
      
        

          
          
                return ""
        
      
        

          
          
              else
        
      
        

          
          
                return request.env["HTTP_REFERER"].gsub('http:', 'https:')
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_http_host
        
      
        

          1
          
              return request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_twiki_http_referer
        
      
        

          
          
              if request.env["HTTP_REFERER"].nil? then
        
      
        

          
          
                return ""
        
      
        

          
          
              else
        
      
        

          
          
                url = request.env["HTTP_REFERER"].gsub('info.west.cmu.edu', 'info.sv.cmu.edu').gsub('https:', 'http:')
        
      
        

          
          
                url_no_query_string = url.split('?')[0]
        
      
        

          
          
                url_no_anchors = url_no_query_string.split('#')[0]
        
      
        

          
          
                return url_no_anchors
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #Temporary method until we merge person and user
        
      
        

          1
          
            def current_person
        
      
        

          90
          
              if current_user
        
      
        

          
          
                Person.find(current_user.id)
        
      
        

          
          
              else
        
      
        

          
          
                nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          ##  In development, if you want to pretend to be a different user, you can set it easily here
        
      
        

          1
          
            def current_user
        
      
        

          1459
          
              User.find_by_twiki_name 'EdKatz' #Cecile
        
      
        

          
          
              #User.last
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_user!
        
      
        

          312
          
              if !current_user
        
      
        

          
          
                # This should work, but session is lost. See https://github.com/plataformatec/devise/issues/1357
        
      
        

          
          
                # session[:return_to] = request.fullpath
        
      
        

          312
          
                redirect_to user_omniauth_authorize_path(:google_apps, :origin => request.fullpath)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def user_profile_status_check
        
      
        

          
          
              if !current_user.profile_updated?
        
      
        

          
          
                if current_user.should_be_redirected?
        
      
        

          
          
                  redirect_to root_path
        
      
        

          
          
                else
        
      
        

          
          
                  #popup a box
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #Return to the page the user was trying to access after a login
        
      
        

          1
          
            def after_sign_in_path_for(resource)
        
      
        

          
          
              # This should work, but session is lost. See https://github.com/plataformatec/devise/issues/1357
        
      
        

          
          
              # return_to = session[:return_to]
        
      
        

          
          
              # session[:return_to] = nil
        
      
        

          101
          
              return_to = request.env['omniauth.origin']
        
      
        

          101
          
              stored_location_for(resource) || return_to || root_path
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def store_location
        
      
        

          
          
              session[:return_to] = request.request_uri
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def store_previous_location
        
      
        

          
          
              session[:return_to] = request.env["HTTP_REFERER"]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def redirect_back_or_default(default)
        
      
        

          
          
              redirect_to(session[:return_to] || default)
        
      
        

          
          
              session[:return_to] = nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # level = :admin, :staff, :student
        
      
        

          1
          
            def has_permissions_or_redirect(level, url)
        
      
        

          1
          
              unless current_user.permission_level_of(level)
        
      
        

          
          
                flash[:error] = t(:no_permission)
        
      
        

          
          
                #          redirect_back_or_default(url)
        
      
        

          
          
                redirect_to(url)
        
      
        

          
          
                return false
        
      
        

          
          
              end
        
      
        

          
          
              return true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            rescue_from CanCan::AccessDenied do |exception|
        
      
        

          
          
              flash[:error] = exception.message #We can remove this line when we upgrade to Rails 3.2
        
      
        

          
          
              redirect_to root_url, :error => exception.message
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Now in locales
        
      
        

          
          
            #def american_date
        
      
        

          
          
            #  '%m/%d/%Y'
        
      
        

          
          
            #end
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          1
          
            def make_available_for_exception_notification
        
      
        

          557
          
              request.env["exception_notifier.exception_data"] = {
        
      
        

          
          
                  :current_user => current_user
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class AssignmentsController < ApplicationController
        
      
        

          
          
            # GET /assignments
        
      
        

          
          
            # GET /assignments.xml
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :get_course
        
      
        

          1
          
            before_filter :render_grade_book_menu
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          1
          
            def get_course
        
      
        

          
          
              @course=Course.find(params[:course_id])
        
      
        

          
          
              @wording = @course.nomenclature_assignment_or_deliverable
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def render_grade_book_menu
        
      
        

          
          
              @is_in_grade_book = true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              @assignments = Assignment.all(:conditions => ["course_id = ?", @course.id])
        
      
        

          
          
              authorize! :read, Assignment
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # index.html.erb
        
      
        

          
          
                format.xml { render :xml => @assignments }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /assignments/new
        
      
        

          
          
            # GET /assignments/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              @assignment = Assignment.new
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @assignment }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /assignments/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @assignment = Assignment.find(params[:id])
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /assignments
        
      
        

          
          
            # POST /assignments.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              @assignment = @course.assignments.new(params[:assignment])
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
              @assignment.set_due_date(params[:due_date][:date], params[:due_date][:hour], params[:due_date][:minute]) if params.has_key?(:due_date)
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @assignment.save
        
      
        

          
          
                  format.html { redirect_to(course_assignments_path, :notice => "#{@wording}  #{@assignment.name} was successfully created.") }
        
      
        

          
          
                  format.xml { render :xml => @assignment, :status => :created, :location => @assignment }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @assignment.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /assignments/1
        
      
        

          
          
            # PUT /assignments/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @assignment = Assignment.find(params[:id])
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
          
        
      
        

          
          
              @assignment.set_due_date(params[:due_date][:date], params[:due_date][:hour], params[:due_date][:minute]) if params.has_key?(:due_date)
        
      
        

          
          
              deliverable_submitted=Deliverable.find_all_by_assignment_id(@assignment.id).first
        
      
        

          
          
              deliverable_status=0;
        
      
        

          
          
              unless deliverable_submitted.nil?
        
      
        

          
          
                if @assignment.is_team_deliverable.to_s!= params[:assignment]["is_team_deliverable"]
        
      
        

          
          
                  deliverable_status=1
        
      
        

          
          
                  flash[:error] = "You cannot change the Type as the student(s) has already submitted for this item."
        
      
        

          
          
          
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if deliverable_status==0
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  if @assignment.update_attributes(params[:assignment])
        
      
        

          
          
                    format.html { redirect_to(course_assignments_path, :notice => "Assignment #{@assignment.name} was successfully updated.") }
        
      
        

          
          
                    format.xml { head :ok }
        
      
        

          
          
                  else
        
      
        

          
          
                    format.html { render :action => "edit" }
        
      
        

          
          
                    format.xml { render :xml => @assignment.errors, :status => :unprocessable_entity }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { render :action => "edit" }
        
      
        

          
          
                  format.xml { render :xml => @assignment.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /assignments/1
        
      
        

          
          
            # DELETE /assignments/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @assignment = Assignment.find(params[:id])
        
      
        

          
          
              authorize! :destroy, @assignment
        
      
        

          
          
          
        
      
        

          
          
              @assignment.destroy
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.js
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # GET /course/assignment_reorder/1
        
      
        

          1
          
            def show
        
      
        

          
          
              @no_pad = true
        
      
        

          
          
              @assignments = @course.assignments
        
      
        

          
          
              authorize! :read, @course
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # showml.erb
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #Inspiration for this technique comes from two sources
        
      
        

          
          
            # A: http://awesomeful.net/posts/47-sortable-lists-with-jquery-in-rails (yield javascript, jquery ui code)
        
      
        

          
          
            # B: http://henrik.nyh.se/2008/11/rails-jquery-sortables#comment-17220662 (model update code)
        
      
        

          
          
          
        
      
        

          1
          
            def reposition
        
      
        

          
          
              authorize! :reorder_assignments, @course
        
      
        

          
          
          
        
      
        

          
          
              order = params[:assignment]
        
      
        

          
          
              Rails.logger.debug(order)
        
      
        

          
          
              Assignment.reposition(order)
        
      
        

          
          
              render :text => order.inspect
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class CourseNavigationsController < ApplicationController
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
            #Inspiration for this technique comes from two sources
        
      
        

          
          
            # A: http://awesomeful.net/posts/47-sortable-lists-with-jquery-in-rails (yield javascript, jquery ui code)
        
      
        

          
          
            # B: http://henrik.nyh.se/2008/11/rails-jquery-sortables#comment-17220662 (model update code)
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # GET /course_navigations/1
        
      
        

          
          
            # GET /course_navigations/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @no_pad = true
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
          
        
      
        

          
          
              @pages = @course.pages
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @pages }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reposition
        
      
        

          
          
              order = params[:page]
        
      
        

          
          
              Page.reposition(order)
        
      
        

          
          
              render :text => order.inspect
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class CourseNumbersController < ApplicationController
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
            # GET /course_numbers
        
      
        

          
          
            # GET /course_numbers.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @courses = Course.unique_course_numbers_and_names_by_number
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
    
  

    

      
        

          1
          
          class CoursesController < ApplicationController
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
            # GET /courses
        
      
        

          
          
            # GET /courses.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @all_courses = true
        
      
        

          
          
              @courses = Course.order("year DESC, semester DESC, number ASC").all
        
      
        

          
          
              @courses = @courses.sort_by { |c| -c.sortable_value } # note the '-' is for desc sorting
        
      
        

          
          
          
        
      
        

          
          
              @registered_for_these_courses_during_current_semester = current_person.registered_for_these_courses_during_current_semester
        
      
        

          
          
              @teaching_these_courses_during_current_semester = current_person.teaching_these_courses_during_current_semester
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def index_for_semester
        
      
        

          
          
              @all_courses = false
        
      
        

          
          
              (@semester, @year) = AcademicCalendar.valid_semester_and_year(params[:semester])
        
      
        

          
          
          
        
      
        

          
          
              if @semester.blank? || @year.blank?
        
      
        

          
          
                current_semester = "#{AcademicCalendar.current_semester()}#{Date.today.year}"
        
      
        

          
          
                flash[:notice] = "The requested url #{request.path} does not look like /courses/semester/#{current_semester} -- Thus we brought you to the current semester."
        
      
        

          
          
                redirect_to("/courses/semester/#{current_semester}")
        
      
        

          
          
                return false
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @courses = Course.for_semester(@semester, @year)
        
      
        

          
          
              @semester_length_courses = @courses.select { |course| course.mini == "Both" }
        
      
        

          
          
              @mini_a_courses = @courses.select { |course| course.mini == "A" }
        
      
        

          
          
              @mini_b_courses = @courses.select { |course| course.mini == "B" }
        
      
        

          
          
          
        
      
        

          
          
              index_core
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #def current_semester
        
      
        

          
          
            #  #@all_courses = false
        
      
        

          
          
            #  @semester = AcademicCalendar.current_semester()
        
      
        

          
          
            #  @year = Date.today.year
        
      
        

          
          
            #  params[:semester] = "#{@semester}#{@year}"
        
      
        

          
          
            #
        
      
        

          
          
            #  #@courses = Course.for_semester(@semester, @year)
        
      
        

          
          
            #  #@semester_length_courses = @courses.select {|course| course.mini == "Both"}
        
      
        

          
          
            #  #@mini_a_courses = @courses.select {|course| course.mini == "A"}
        
      
        

          
          
            #  #@mini_b_courses = @courses.select {|course| course.mini == "B"}
        
      
        

          
          
            #  #
        
      
        

          
          
            #  #index_core
        
      
        

          
          
            #  index_for_semester
        
      
        

          
          
            #end
        
      
        

          
          
            #
        
      
        

          
          
            #def next_semester
        
      
        

          
          
            #  @all_courses = false
        
      
        

          
          
            #  @semester = AcademicCalendar.next_semester()
        
      
        

          
          
            #  @year = AcademicCalendar.next_semester_year()
        
      
        

          
          
            #
        
      
        

          
          
            #  @courses = Course.for_semester(@semester, @year)
        
      
        

          
          
            #  @semester_length_courses = @courses.select {|course| course.mini == "Both"}
        
      
        

          
          
            #  @mini_a_courses = @courses.select {|course| course.mini == "A"}
        
      
        

          
          
            #  @mini_b_courses = @courses.select {|course| course.mini == "B"}
        
      
        

          
          
            #
        
      
        

          
          
            #  index_core
        
      
        

          
          
            #end
        
      
        

          
          
          
        
      
        

          
          
            # GET /courses/1
        
      
        

          
          
            # GET /courses/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
              first_version_of_course = Course.first_offering_for_course_name(@course.name)
        
      
        

          
          
              @whiteboard_curriculum_page = first_version_of_course.pages[0] if first_version_of_course.pages.present?
        
      
        

          
          
          
        
      
        

          
          
              if (can? :teach, @course) || current_user.is_admin?
        
      
        

          
          
                @students = @course.registered_students_and_students_on_teams_hash
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @course }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def tool_support
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
              authorize! :teach, @course
        
      
        

          
          
          
        
      
        

          
          
              teams = Team.where(:course_id => params[:id])
        
      
        

          
          
              @emails = []
        
      
        

          
          
              teams.each do |team|
        
      
        

          
          
                team.members.each do |user|
        
      
        

          
          
                  @emails << user.email
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /courses/new
        
      
        

          
          
            # GET /courses/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              authorize! :create, Course
        
      
        

          
          
              @course = Course.new(:grading_rule => GradingRule.new)
        
      
        

          
          
              @course.semester = AcademicCalendar.next_semester
        
      
        

          
          
              @course.year = AcademicCalendar.next_semester_year
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @course }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /courses/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @is_in_grade_book = true
        
      
        

          
          
              store_previous_location
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
              if @course.grading_rule.nil?
        
      
        

          
          
                @course.grading_rule = GradingRule.new
        
      
        

          
          
              end
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def configure
        
      
        

          
          
              edit
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /courses
        
      
        

          
          
            # POST /courses.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              authorize! :create, Course
        
      
        

          
          
              @last_offering = Course.last_offering(params[:course][:number])
        
      
        

          
          
              if @last_offering.nil?
        
      
        

          
          
                @course = Course.new(:name => "New Course", :mini => "Both", :number => params[:course][:number])
        
      
        

          
          
              else
        
      
        

          
          
                @course = @last_offering.copy_as_new_course
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @course.year = params[:course][:year]
        
      
        

          
          
              @course.semester = params[:course][:semester]
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                @course.updated_by_user_id = current_user.id if current_user
        
      
        

          
          
                if @course.save
        
      
        

          
          
          
        
      
        

          
          
                  flash[:notice] = 'Course was successfully created.'
        
      
        

          
          
                  format.html { redirect_to edit_course_path(@course) }
        
      
        

          
          
                  format.xml { render :xml => @course, :status => :created, :location => @course }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @course.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /courses/1
        
      
        

          
          
            # PUT /courses/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
              authorize! :update, @course
        
      
        

          
          
          
        
      
        

          
          
              if (params[:course][:is_configured]) #The previous page was configure action
        
      
        

          
          
                if params[:course][:curriculum_url].include?("info.sv.cmu.edu")
        
      
        

          
          
                  @course.twiki_url = params[:course][:curriculum_url].sub("https", "http")
        
      
        

          
          
                end
        
      
        

          
          
                @course.configured_by_user_id = current_user.id
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              params[:course][:faculty_assignments_override] = params[:teachers]
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                @course.updated_by_user_id = current_user.id if current_user
        
      
        

          
          
                @course.attributes = params[:course]
        
      
        

          
          
                if @course.save
        
      
        

          
          
                  flash[:notice] = 'Course was successfully updated.'
        
      
        

          
          
                  format.html { redirect_back_or_default(course_path(@course)) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "configure" }
        
      
        

          
          
                  format.xml { render :xml => @course.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /courses/1
        
      
        

          
          
            # DELETE /courses/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              if has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
                @course = Course.find(params[:id])
        
      
        

          
          
                @course.destroy
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { redirect_to(courses_url) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def upload
        
      
        

          
          
              require 'HUB_class_roster_handler'
        
      
        

          
          
          
        
      
        

          
          
              authorize! :upload, Course
        
      
        

          
          
              store_previous_location
        
      
        

          
          
              file_content = params[:file].read()
        
      
        

          
          
          
        
      
        

          
          
              begin
        
      
        

          
          
                changes_applied = HUBClassRosterHandler::handle(file_content)
        
      
        

          
          
                if changes_applied
        
      
        

          
          
                  flash[:notice] = 'Roster file was parsed and handled successfully.'
        
      
        

          
          
                else
        
      
        

          
          
                  flash[:notice] = 'Roster file parsed successfully, but no changes made.'
        
      
        

          
          
                end
        
      
        

          
          
              rescue Exception => ex
        
      
        

          
          
                flash[:error] = "There was a problem parsing your roster file: #{ex.message}"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { redirect_back_or_default(courses_path) }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def team_formation_tool
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
              authorize! :team_formation, @course
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { render :html => @teams, :layout => "cmu_sv" } # index.html.erb
        
      
        

          
          
                format.xml { render :xml => @teams }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def export_to_csv
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
              authorize! :team_formation, @course
        
      
        

          
          
          
        
      
        

          
          
              report = CSV.generate do |title|
        
      
        

          
          
                title << ['Person', 'Current Team', 'Past Teams', "Part Time", "Local/Near/Remote", "Program", "State", "Company Name"]
        
      
        

          
          
                @course.registered_students.each do |user|
        
      
        

          
          
                  current_team = @course.teams.collect { |team| team if team.members.include?(user) }.compact
        
      
        

          
          
                  part_time = user.is_part_time ? "PT" : "FT"
        
      
        

          
          
                  title << [user.human_name, user.formatted_teams(current_team), user.formatted_teams(user.past_teams), part_time, user.local_near_remote, user.masters_program + " " + user.masters_track, user.work_state, user.organization_name]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              send_data(report, :type => 'text/csv;charset=iso-8859-1;', :filename => "past_teams_for_#{@course.display_course_name}.csv",
        
      
        

          
          
                        :disposition => 'attachment', :encoding => 'utf8')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def index_core
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { render :action => "index" }
        
      
        

          
          
                format.xml { render :xml => @courses }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class DelayedSystemJobsController < ApplicationController
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              @no_pad = true
        
      
        

          
          
              if has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
          
        
      
        

          
          
                @delayed_system_jobs = DelayedSystemJob.all
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { render :html => @delayed_system_jobs, :layout => "cmu_sv" } # index.html.erb
        
      
        

          
          
                  format.js { render :js => @delayed_system_jobs, :layout => false }
        
      
        

          
          
                  format.xml { render :xml => @delayed_system_jobs }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /delayed_systems_job/1
        
      
        

          
          
            # DELETE /delayed_systems_job/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              if has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
          
        
      
        

          
          
                delayed_system_job = DelayedSystemJob.find(params[:id])
        
      
        

          
          
                delayed_system_job.destroy
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { redirect_to("/delayed_system_jobs") }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class DeliverablesController < ApplicationController
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          
          
            
        
      
        

          1
          
            before_filter :render_grade_book_menu, :only => [:grading_queue_for_course, :show]
        
      
        

          
          
          
        
      
        

          1
          
            def render_grade_book_menu
        
      
        

          7
          
              @is_in_grade_book = true if (current_user.is_staff?)||(current_user.is_admin?)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /deliverables
        
      
        

          
          
            # GET /deliverables.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              redirect_to my_deliverables_path(current_user)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def grading_queue_for_course
        
      
        

          
          
          
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
          
        
      
        

          
          
              if @course.grading_rule.nil?
        
      
        

          
          
                flash[:error] = I18n.t(:no_grading_rule_for_course)
        
      
        

          
          
                redirect_to course_path(@course) and return
        
      
        

          
          
              end
        
      
        

          
          
              if @course.grading_rule.default_values?
        
      
        

          
          
                flash.now[:error] = I18n.t(:default_grading_rule_for_course)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Retrieving assignments names for the course to be able to filter by deliverable name later on.
        
      
        

          
          
              # @assignments = Assignment.where(:course_id => @course.id).all
        
      
        

          
          
              # Team Turing: this fails when the task is nil.
        
      
        

          
          
              @assignments = Assignment.where(:course_id => @course.id).all.sort_by(&:task_number)
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              if @course.faculty.include?(current_user)
        
      
        

          
          
                # Get all deliverables for this team/student
        
      
        

          
          
                @deliverables = Deliverable.get_deliverables(params[:course_id], current_user.id, {:is_my_team => 1})
        
      
        

          
          
          
        
      
        

          
          
                @deliverables = @deliverables.select { |deliverable| deliverable.grade_status == "ungraded" }
        
      
        

          
          
          
        
      
        

          
          
                @deliverables = @deliverables.sort { |a, b| b.assignment.assignment_order <=> a.assignment.assignment_order }
        
      
        

          
          
              else
        
      
        

          
          
                has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_deliverables
        
      
        

          5
          
              filter_options = params[:filter_options] || Hash.new
        
      
        

          5
          
              @deliverables = filter_deliverables(params[:course_id], filter_options)
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.js
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #temporary for mel
        
      
        

          1
          
            def team_index_for_course
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
              if (current_user.is_admin? || @course.faculty.include?(current_user))
        
      
        

          
          
                @deliverables = Deliverable.where("team_id is not null").find_all_by_course_id(@course.id)
        
      
        

          
          
              else
        
      
        

          
          
                has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #temporary for mel
        
      
        

          1
          
            def individual_index_for_course
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
              if (current_user.is_admin? || @course.faculty.include?(current_user))
        
      
        

          
          
                @deliverables = Deliverable.where("team_id is null").find_all_by_course_id(@course.id)
        
      
        

          
          
              else
        
      
        

          
          
                has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def my_deliverables
        
      
        

          3
          
              user = User.find_by_param(params[:id])
        
      
        

          3
          
              if (current_user.id != user.id)
        
      
        

          
          
                unless (current_user.is_staff?)||(current_user.is_admin?)
        
      
        

          
          
                  flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                  redirect_to root_path
        
      
        

          
          
                  return
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              @current_deliverables = Deliverable.find_current_by_user(user)
        
      
        

          
          
              @past_deliverables = Deliverable.find_past_by_user(user)
        
      
        

          
          
              @current_assignments = Assignment.list_assignments_for_student(user.id, :current)
        
      
        

          
          
              @current_courses = user.registered_for_these_courses_during_current_semester()
        
      
        

          
          
              @past_assignments = Assignment.list_assignments_for_student(user.id, :past)
        
      
        

          
          
              @past_courses = user.registered_for_these_courses_during_past_semesters()
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { render :action => "index" }
        
      
        

          
          
                format.xml { render :xml => @deliverables }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /deliverables/1
        
      
        

          
          
            # GET /deliverables/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
              @course = @deliverable.course
        
      
        

          
          
              @hostname_with_port = request.host_with_port
        
      
        

          
          
              unless @deliverable.editable?(current_user)
        
      
        

          
          
                flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                redirect_to root_path and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if (current_user.is_admin? || @course.faculty.include?(current_user))
        
      
        

          
          
                if @course.grading_rule.nil?
        
      
        

          
          
                  flash[:error] = I18n.t(:no_grading_rule_for_course)
        
      
        

          
          
                  redirect_to course_path(@course) and return
        
      
        

          
          
                end
        
      
        

          
          
                if @course.grading_rule.default_values?
        
      
        

          
          
                  flash.now[:error] = I18n.t(:default_grading_rule_for_course)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if (current_user.is_admin? || @course.faculty.include?(current_user))
        
      
        

          
          
                  format.html { render layout: false }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html # show.html.erb
        
      
        

          
          
                  format.xml { render :xml => @deliverable }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /deliverables/new
        
      
        

          
          
            # GET /deliverables/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              # If we aren't on this deliverable's team, you can't see it.
        
      
        

          
          
              @deliverable = Deliverable.new(:creator => current_user)
        
      
        

          
          
              @courses = current_user.registered_for_these_courses_during_current_semester
        
      
        

          
          
          
        
      
        

          
          
              if params[:course_id]
        
      
        

          
          
                @deliverable.course_id = params[:course_id]
        
      
        

          
          
                @assignments = Course.find(params[:course_id]).assignments.where(:is_submittable => true)
        
      
        

          
          
              else
        
      
        

          
          
                if @courses.empty?
        
      
        

          
          
                  @assignments = []
        
      
        

          
          
                else
        
      
        

          
          
                  @assignments = @courses[0].assignments.where(:is_submittable => true)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @deliverable }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /deliverables/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              @courses = current_user.registered_for_these_courses_during_current_semester
        
      
        

          
          
              @assignments = @deliverable.course.assignments.where(:is_submittable => true)
        
      
        

          
          
          
        
      
        

          
          
              unless @deliverable.editable?(current_user)
        
      
        

          
          
                flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                redirect_to root_path and return
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /deliverables
        
      
        

          
          
            # POST /deliverables.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              # Make sure that a file was specified
        
      
        

          
          
              @deliverable = Deliverable.new(params[:deliverable])
        
      
        

          
          
              @deliverable.creator = current_user
        
      
        

          
          
              @deliverable.is_team_deliverable ? @deliverable.update_team : @deliverable.team = nil
        
      
        

          
          
          
        
      
        

          
          
              if @deliverable.is_team_deliverable && @deliverable.team == nil
        
      
        

          
          
                flash[:error] = "You are not on a team in this course, so you can't submit a team deliverable"
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @deliverable.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if !params[:deliverable_attachment][:attachment]
        
      
        

          
          
                flash[:error] = 'Must specify a file to upload'
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @deliverable.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              @attachment = DeliverableAttachment.new(params[:deliverable_attachment])
        
      
        

          
          
              @attachment.submitter = @deliverable.creator
        
      
        

          
          
              @deliverable.attachment_versions << @attachment
        
      
        

          
          
              @attachment.deliverable = @deliverable
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @attachment.valid? and @deliverable.valid? and @deliverable.save
        
      
        

          
          
                  @deliverable.send_deliverable_upload_email(url_for(@deliverable))
        
      
        

          
          
                  flash[:notice] = 'Deliverable was successfully created.'
        
      
        

          
          
                  format.html { redirect_to(@deliverable) }
        
      
        

          
          
                  format.xml { render :xml => @deliverable, :status => :created, :location => @deliverable }
        
      
        

          
          
                else
        
      
        

          
          
                  if not @attachment.valid?
        
      
        

          
          
                    flash[:notice] = 'Attachment not valid'
        
      
        

          
          
                  elsif not @deliverable.valid?
        
      
        

          
          
                    flash[:notice] = 'Deliverable not valid'
        
      
        

          
          
                  else
        
      
        

          
          
                    flash[:notice] = 'Something else went wrong'
        
      
        

          
          
                  end
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @deliverable.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /deliverables/1
        
      
        

          
          
            # PUT /deliverables/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
          #    params[:is_team_deliverable] ? @deliverable.update_team : @deliverable.team = nil
        
      
        

          
          
              @deliverable.is_team_deliverable ? @deliverable.update_team : @deliverable.team = nil
        
      
        

          
          
          
        
      
        

          
          
              unless @deliverable.editable?(current_user)
        
      
        

          
          
                flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                redirect_to root_path and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              there_is_an_attachment = params[:deliverable_attachment][:attachment]
        
      
        

          
          
              if there_is_an_attachment
        
      
        

          
          
          
        
      
        

          
          
                @attachment = DeliverableAttachment.new(params[:deliverable_attachment])
        
      
        

          
          
                @attachment.submitter = current_user
        
      
        

          
          
                @deliverable.attachment_versions << @attachment
        
      
        

          
          
                @attachment.deliverable = @deliverable
        
      
        

          
          
          
        
      
        

          
          
                if @attachment.valid? and @deliverable.valid? and @deliverable.update_attributes(params[:deliverable])
        
      
        

          
          
                  @deliverable.send_deliverable_upload_email(url_for(@deliverable))
        
      
        

          
          
                  flash[:notice] = 'Deliverable was successfully updated.'
        
      
        

          
          
                  redirect_to(@deliverable)
        
      
        

          
          
                else
        
      
        

          
          
                  render :action => "edit"
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                if @deliverable.valid? and @deliverable.update_attributes(params[:deliverable])
        
      
        

          
          
                  flash[:notice] = 'Deliverable was successfully updated.'
        
      
        

          
          
                  redirect_to(@deliverable)
        
      
        

          
          
                else
        
      
        

          
          
                  render :action => "edit"
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /deliverables/1
        
      
        

          
          
            # DELETE /deliverables/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              unless @deliverable.editable?(current_user)
        
      
        

          
          
                flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                redirect_to root_path and return
        
      
        

          
          
              end
        
      
        

          
          
              @deliverable.destroy
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { redirect_to(deliverables_url) }
        
      
        

          
          
                format.xml { head :ok }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def edit_feedback
        
      
        

          
          
              if @course.grading_rule.nil?
        
      
        

          
          
                flash[:error] = I18n.t(:no_grading_rule_for_course)
        
      
        

          
          
                redirect_to course_path(@course) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
          #    if !@deliverable.assignment.course.faculty.include?(current_user)
        
      
        

          
          
          #      flash[:error] = "Only faculty teaching this course can provide feedback on deliverables. #{current_user.human_name}"
        
      
        

          
          
          #      redirect_to :controller => "welcome", :action => "index"
        
      
        

          
          
          #      return
        
      
        

          
          
          #    end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def update_feedback
        
      
        

          
          
              @deliverable = Deliverable.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              unless (current_user.is_admin? || @deliverable.course.faculty.include?(current_user))
        
      
        

          
          
                flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                redirect_to root_path and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # check is save and email is clicked or save as draft is clicked
        
      
        

          
          
              is_student_visible=true
        
      
        

          
          
              if params[:submit]
        
      
        

          
          
                is_student_visible=true
        
      
        

          
          
                @deliverable.update_attributes(:grade_status => "graded")
        
      
        

          
          
              elsif params[:draft]
        
      
        

          
          
                is_student_visible=false
        
      
        

          
          
                @deliverable.update_attributes(:grade_status => "drafted")
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              flash[:error] = @deliverable.update_grade(params, is_student_visible, current_user.id)
        
      
        

          
          
              other_email = nil
        
      
        

          
          
              if params[:send_copy_to_myself] == "1"
        
      
        

          
          
                other_email = current_user.email
        
      
        

          
          
              end
        
      
        

          
          
              if @deliverable.update_feedback_and_notes(params[:deliverable])
        
      
        

          
          
                if is_student_visible == true
        
      
        

          
          
                  @deliverable.send_deliverable_feedback_email(url_for(@deliverable), other_email)
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] << 'Unable to save feedback'
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              #Obtain current selected filters to update the queue accordingly
        
      
        

          
          
              if params[:deliverable][:current_filter_options].present?
        
      
        

          
          
                @selected_filter_options = JSON.parse(params[:deliverable][:current_filter_options])
        
      
        

          
          
              else
        
      
        

          
          
                @selected_filter_options = Hash.new
        
      
        

          
          
              end
        
      
        

          
          
              @deliverables = filter_deliverables(@deliverable.course_id, @selected_filter_options)
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if flash[:error].blank?
        
      
        

          
          
                  flash[:error] = nil
        
      
        

          
          
                  flash[:notice] = 'Feedback successfully saved.'
        
      
        

          
          
                  format.js
        
      
        

          
          
                else
        
      
        

          
          
                  flash[:error] = flash[:error].join("<br>")
        
      
        

          
          
                  format.html { redirect_to(@deliverable) }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #Todo: rename this method
        
      
        

          
          
            #get_assginemments_for_course
        
      
        

          
          
            #shouldn't this be in the assignments controller?
        
      
        

          1
          
            def get_assignments_for_student
        
      
        

          
          
              unless params[:course_id].nil?
        
      
        

          
          
                @assignments = Course.find(params[:course_id]).assignments.all(:conditions => ["is_submittable = ?", true])
        
      
        

          
          
                @assignments_array = @assignments.collect { |assignment| {:assignment => assignment.attributes.merge({:name_with_type => assignment.name_with_type})} }
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.json { render json: @assignments_array }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def filter_deliverables (course_id, filter_options)
        
      
        

          5
          
              @course = Course.find_by_id(course_id)
        
      
        

          
          
          
        
      
        

          
          
              # Prepare filter options according to what users select on the page
        
      
        

          5
          
              options = {}
        
      
        

          5
          
              if filter_options[:search_box] != ""
        
      
        

          1
          
                options[:search_string] = filter_options[:search_box]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          5
          
              if filter_options['is_my_teams'] == 'yes'
        
      
        

          5
          
                options[:is_my_team] = 1
        
      
        

          
          
              else
        
      
        

          
          
                options[:is_my_team] = 0
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              # Filter in the model by course, professor, my teams and search input
        
      
        

          5
          
              @deliverables = []
        
      
        

          5
          
              @faculty_deliverables = Deliverable.get_deliverables(course_id, current_user.id, options)
        
      
        

          
          
          
        
      
        

          
          
              # Filter once again according to the selected grading options. If no filter options are selected,
        
      
        

          
          
              # display every deliverable
        
      
        

          
          
              @selected_options = []
        
      
        

          
          
              filter_options.collect do |filter_option|
        
      
        

          
          
                @selected_options << filter_option[0].to_sym if filter_option[1] == "1"
        
      
        

          
          
              end
        
      
        

          
          
              if @selected_options.size == 0
        
      
        

          
          
                @deliverables = @faculty_deliverables
        
      
        

          
          
              else
        
      
        

          
          
                @selected_options.each do |option|
        
      
        

          
          
          #        @deliverables.concat(@faculty_deliverables.select { |deliverable| deliverable.get_grade_status == option })
        
      
        

          
          
                  @deliverables.concat(@faculty_deliverables.select { |deliverable| deliverable.grade_status == option.to_s })
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Filter by assignment names in drop down menu
        
      
        

          
          
              unless filter_options["assignment_id"] == '-1'
        
      
        

          
          
                @deliverables = @deliverables.select { |deliverable| deliverable.assignment_id == filter_options[
        
      
        

          
          
                    "assignment_id"].to_i }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @deliverables = @deliverables.sort { |a, b| b.assignment.assignment_order <=> a.assignment.assignment_order }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
    
  

    

      
        

          
          
          #
        
      
        

          
          
          #
        
      
        

          
          
          # Todo: consider removing this controller entirely.....
        
      
        

          
          
          #
        
      
        

          
          
          #
        
      
        

          
          
          #
        
      
        

          1
          
          class EffortLogLineItemsController < ApplicationController
        
      
        

          
          
            # GET /effort_log_line_items
        
      
        

          
          
            # GET /effort_log_line_items.xml
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :redirect_to_effort_log_index
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              @effort_log_line_items = EffortLogLineItem.all
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # index.html.erb
        
      
        

          
          
                format.xml { render :xml => @effort_log_line_items }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_log_line_items/1
        
      
        

          
          
            # GET /effort_log_line_items/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @effort_log_line_item }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_log_line_items/new
        
      
        

          
          
            # GET /effort_log_line_items/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.new
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @effort_log_line_item }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_log_line_items/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
          
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.find(params[:id])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /effort_log_line_items
        
      
        

          
          
            # POST /effort_log_line_items.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.new(params[:effort_log_line_item])
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @effort_log_line_item.save
        
      
        

          
          
                  flash[:notice] = 'EffortLogLineItem was successfully created.'
        
      
        

          
          
                  format.html { redirect_to(@effort_log_line_item) }
        
      
        

          
          
                  format.xml { render :xml => @effort_log_line_item, :status => :created, :location => @effort_log_line_item }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @effort_log_line_item.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /effort_log_line_items/1
        
      
        

          
          
            # PUT /effort_log_line_items/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @effort_log_line_item.update_attributes(params[:effort_log_line_item])
        
      
        

          
          
                  flash[:notice] = 'EffortLogLineItem was successfully updated.'
        
      
        

          
          
                  format.html { redirect_to(@effort_log_line_item) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "edit" }
        
      
        

          
          
                  format.xml { render :xml => @effort_log_line_item.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /effort_log_line_items/1
        
      
        

          
          
            # DELETE /effort_log_line_items/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.find(params[:id])
        
      
        

          
          
              @effort_log_line_item.destroy
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { redirect_to(effort_log_line_items_url) }
        
      
        

          
          
                format.xml { head :ok }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          1
          
            def redirect_to_effort_log_index
        
      
        

          
          
              redirect_to :controller => :effort_logs, :action => :index
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class EffortLogsController < ApplicationController
        
      
        

          
          
          #  layout "cmu_sv_no_pad", :except => :new_effort_log_line_item
        
      
        

          
          
          
        
      
        

          
          
          #  layout 'cmu_sv_no_pad', :only => [:index, :show]
        
      
        

          1
          
            layout 'simple'
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!, :except => [:create_midweek_warning_email, :create_endweek_admin_email]
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # Todo: consider moving these email methods to the model(EffortLogs) and update the rake task accordingly
        
      
        

          
          
            #
        
      
        

          1
          
            def create_midweek_warning_email
        
      
        

          7
          
              if (!EffortLog.log_effort_week?(Date.today.cwyear, Date.today.cweek))
        
      
        

          
          
                #We skip weeks that students aren't taking courses
        
      
        

          1
          
                logger.info "There is no class this week, so we won't remind students to log effort"
        
      
        

          1
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          6
          
              random_scotty_saying = ScottyDogSaying.all.sample.saying
        
      
        

          
          
          
        
      
        

          6
          
              courses = Course.remind_about_effort_course_list
        
      
        

          6
          
              courses.each do |course_id|
        
      
        

          6
          
                create_midweek_warning_email_for_course(random_scotty_saying, course_id)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create_midweek_warning_email_for_course(random_scotty_saying, course_id)
        
      
        

          7
          
              year = Date.today.cwyear
        
      
        

          7
          
              week_number = Date.today.cweek
        
      
        

          
          
          
        
      
        

          7
          
              course = Course.find(course_id)
        
      
        

          7
          
              users = course.registered_students | course.teams.collect { |team| team.members }.flatten
        
      
        

          7
          
              users.each do |user|
        
      
        

          6
          
                logger.debug "**    user #{user.human_name}"
        
      
        

          6
          
                effort_log = EffortLog.where(:user_id => user.id, :week_number => week_number, :year => year).first
        
      
        

          6
          
                if (!user.emailed_recently(:effort_log))
        
      
        

          4
          
                  EffortLogMailer.midweek_warning(random_scotty_saying, user).deliver
        
      
        

          4
          
                  user.effort_log_warning_email = Time.now
        
      
        

          4
          
                  user.save
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create_endweek_faculty_email
        
      
        

          
          
              notify_course_list = Course.remind_about_effort_course_list
        
      
        

          
          
          
        
      
        

          
          
              #notify_course_list = [48, 47, 46]  #list all courses that we want to track effort
        
      
        

          
          
              last_week = (Date.today - 7).cweek
        
      
        

          
          
              last_week_year = (Date.today -7).cwyear
        
      
        

          
          
          
        
      
        

          
          
              if (!EffortLog.log_effort_week?(last_week_year, last_week))
        
      
        

          
          
                logger.info "There was no class last week, so we won't remind students to log effort"
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              notify_course_list.each do |course|
        
      
        

          
          
                faculty = {}
        
      
        

          
          
                teams = Team.where(:course_id => course.id)
        
      
        

          
          
                teams.each do |team|
        
      
        

          
          
                  faculty[team.primary_faculty_id] = 1 unless team.primary_faculty_id.nil?
        
      
        

          
          
                  faculty[team.secondary_faculty_id] = 1 unless team.secondary_faculty_id.nil?
        
      
        

          
          
                end
        
      
        

          
          
                faculty_emails = []
        
      
        

          
          
                faculty.each { |faculty_id, value| faculty_emails << User.find_by_id(faculty_id).email }
        
      
        

          
          
                EffortLogMailer.endweek_admin_report(course.id, course.name, faculty_emails).deliver
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_task_type_select
        
      
        

          
          
              unless params[:task_id].blank?
        
      
        

          
          
                logger.debug "updated " + params[:task_id]
        
      
        

          
          
                @selected_type = TaskType.find_by_id(params[:task_id])
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              render :partial => "description_update"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_logs
        
      
        

          
          
            # GET /effort_logs.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @effort_logs = EffortLog.find_effort_logs(current_user)
        
      
        

          
          
          
        
      
        

          
          
              if Date.today.cweek == 1 #If the first week of the year, then we set to the last week of previous year
        
      
        

          
          
                @prior_week_number = 52
        
      
        

          
          
                @year = Date.today.cwyear - 1
        
      
        

          
          
              else
        
      
        

          
          
                @prior_week_number = Date.today.cweek - 1
        
      
        

          
          
                @year = Date.today.cwyear
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # if no effort logs created
        
      
        

          
          
              if @effort_logs.empty?
        
      
        

          
          
                # show new current link
        
      
        

          
          
                @show_new_link = true
        
      
        

          
          
          
        
      
        

          
          
                # if no effort logs created and today is Monday, then show new prior link
        
      
        

          
          
                if Date.today.cwday == 1
        
      
        

          
          
                  @show_prior_week = true
        
      
        

          
          
                else
        
      
        

          
          
                  @show_prior_week = false
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                # if most recent effort log is for current period, then don't show new current link, else show new current link
        
      
        

          
          
                if @effort_logs[0].year == Date.today.cwyear && @effort_logs[0].week_number == Date.today.cweek
        
      
        

          
          
                  @show_new_link = false
        
      
        

          
          
                else
        
      
        

          
          
                  @show_new_link = true
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # start by always showing prior week link
        
      
        

          
          
                @show_prior_week = true
        
      
        

          
          
          
        
      
        

          
          
                #if today is Monday, evaluate, otherwise don't show prior week link
        
      
        

          
          
                if Date.today == Date.commercial(Date.today.cwyear, Date.today.cweek, 1)
        
      
        

          
          
                  # if most recent log is a match, then don't show prior week link
        
      
        

          
          
                  if (@effort_logs[0].year == @year && @effort_logs[0].week_number == @prior_week_number)
        
      
        

          
          
                    @show_prior_week = false
        
      
        

          
          
                  end
        
      
        

          
          
                  # if second most recent entry is a match, then don't show prior week link
        
      
        

          
          
                  if @effort_logs[1]
        
      
        

          
          
                    if (@effort_logs[1].year == @year && @effort_logs[1].week_number == @prior_week_number)
        
      
        

          
          
                      @show_prior_week = false
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
                  # if not Monday, don't ever show the prior week link
        
      
        

          
          
                  @show_prior_week = false
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # index.html.erb
        
      
        

          
          
                format.xml { render :xml => @effort_logs }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_logs/1
        
      
        

          
          
            # GET /effort_logs/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @effort_log = EffortLog.find(params[:id])
        
      
        

          
          
              setup_required_datastructures(@effort_log.year, @effort_log.week_number)
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @effort_log }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_logs/new
        
      
        

          
          
            # GET /effort_logs/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              if params[:prior] == 'true' then
        
      
        

          
          
                if Date.today.cweek == 1
        
      
        

          
          
                  week_number = 52
        
      
        

          
          
                  year = Date.today.cwyear -1
        
      
        

          
          
                else
        
      
        

          
          
                  week_number = Date.today.cweek - 1
        
      
        

          
          
                  year = Date.today.cwyear
        
      
        

          
          
                end
        
      
        

          
          
                error_msg = "There already is an effort log for the previous week"
        
      
        

          
          
              else
        
      
        

          
          
                week_number = Date.today.cweek
        
      
        

          
          
                year = Date.today.cwyear
        
      
        

          
          
                error_msg = "There already is an effort log for the current week"
        
      
        

          
          
              end
        
      
        

          
          
              setup_required_datastructures(year, week_number)
        
      
        

          
          
          
        
      
        

          
          
              @effort_log = EffortLog.new
        
      
        

          
          
              @effort_log.user_id = current_user.id
        
      
        

          
          
          
        
      
        

          
          
              #find the most recent effort log to copy its structure, but not its effort data
        
      
        

          
          
              recent_effort_log = EffortLog.where(:user_id => current_user.id).order("year DESC, week_number DESC").first
        
      
        

          
          
          
        
      
        

          
          
              # We want to make sure that the user isn't accidentally creating two efforts for the same week.
        
      
        

          
          
              # Since students are only able to log effort for this week (or a previous week)
        
      
        

          
          
              if recent_effort_log and recent_effort_log.week_number == week_number
        
      
        

          
          
                #Yes we already have effort for this week
        
      
        

          
          
                duplicate_effort_log = recent_effort_log
        
      
        

          
          
              else
        
      
        

          
          
                #Do we already have effort for the week we are trying to log effort against?
        
      
        

          
          
                duplicate_effort_log = EffortLog.where(:user_id => current_user.id, :week_number => week_number, :year => year).first
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if duplicate_effort_log
        
      
        

          
          
                logger.debug "We should not be creating another effort log for week #{week_number}"
        
      
        

          
          
                flash[:error] = error_msg
        
      
        

          
          
                redirect_to(effort_logs_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if recent_effort_log
        
      
        

          
          
                logger.debug "Copy effort log from week #{recent_effort_log.week_number}"
        
      
        

          
          
                recent_effort_log.effort_log_line_items.each do |line|
        
      
        

          
          
                  @effort_log.effort_log_line_items << EffortLogLineItem.new(:course_id => line.course_id, :task_type_id => line.task_type_id)
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                logger.debug "This is the first effort log for the person in the system"
        
      
        

          
          
          
        
      
        

          
          
                course = recent_foundations_or_course
        
      
        

          
          
                course_id = course.id
        
      
        

          
          
          
        
      
        

          
          
                @task_types.each do |task_type|
        
      
        

          
          
                  @effort_log.effort_log_line_items << EffortLogLineItem.new(:course_id => course_id, :task_type_id => task_type.id)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Ps. if we wanted to have an effort log with a single effort log line item that is blank, then this would do it       @effort_log.effort_log_line_items.build      
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              @effort_log.year = year
        
      
        

          
          
              @effort_log.week_number = week_number
        
      
        

          
          
          
        
      
        

          
          
          #          format.html # new.html.erb
        
      
        

          
          
          #      format.xml  { render :xml => @effort_log }
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @effort_log.save
        
      
        

          
          
                  flash[:notice] = 'EffortLog was successfully created.'
        
      
        

          
          
                  format.html { redirect_to(edit_effort_log_url(@effort_log.id)) }
        
      
        

          
          
                  format.xml { render :xml => @effort_log, :status => :created, :location => @effort_log }
        
      
        

          
          
                else
        
      
        

          
          
                  flash[:notice] = 'Unable to create new EffortLog.'
        
      
        

          
          
                  format.html { redirect_to(effort_logs_url) }
        
      
        

          
          
                  format.xml { render :xml => @effort_log.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /effort_logs/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @effort_log = EffortLog.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
          #    if @effort_log.week_number != Date.today.cweek
        
      
        

          
          
              if !@effort_log.editable_by(current_user)
        
      
        

          
          
                flash[:error] = 'You do not have permission to edit the effort log.'
        
      
        

          
          
                redirect_to(effort_logs_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          #    if !@effort_log.has_permission_to_edit_period(current_user)
        
      
        

          
          
          #      flash[:error] = 'You are unable to update effort logs from the past.'
        
      
        

          
          
          #      redirect_to(effort_logs_url) and return
        
      
        

          
          
          #    end
        
      
        

          
          
              setup_required_datastructures(@effort_log.year, @effort_log.week_number)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /effort_logs
        
      
        

          
          
            # POST /effort_logs.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              @effort_log = EffortLog.new(params[:effort_log])
        
      
        

          
          
          
        
      
        

          
          
              setup_required_datastructures(@effort_log.year, @effort_log.week_number)
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @effort_log.save
        
      
        

          
          
                  course_error_msg = @effort_log.validate_effort_against_registered_courses()
        
      
        

          
          
                  flash[:notice] = 'EffortLog was successfully created.'
        
      
        

          
          
                  if (course_error_msg!="")
        
      
        

          
          
                    flash[:error] = 'You are not on a team in the following course(s) ' + course_error_msg
        
      
        

          
          
                  end
        
      
        

          
          
                  format.html { redirect_to(@effort_log) }
        
      
        

          
          
                  format.xml { render :xml => @effort_log, :status => :created, :location => @effort_log }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @effort_log.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /effort_logs/1
        
      
        

          
          
            # PUT /effort_logs/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              params[:effort_log][:existing_effort_log_line_item_attributes] ||= {}
        
      
        

          
          
          
        
      
        

          
          
              @effort_log = EffortLog.find(params[:id])
        
      
        

          
          
              if !@effort_log.editable_by(current_user)
        
      
        

          
          
                flash[:error] = 'You do not have permission to edit the effort log.'
        
      
        

          
          
                redirect_to(effort_logs_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          #    if !@effort_log.has_permission_to_edit_period(current_user)
        
      
        

          
          
          #      flash[:error] = 'You are unable to update effort logs from the past.'
        
      
        

          
          
          #      redirect_to(effort_logs_url) and return
        
      
        

          
          
          #    end
        
      
        

          
          
          
        
      
        

          
          
              setup_required_datastructures(@effort_log.year, @effort_log.week_number)
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @effort_log.update_attributes(params[:effort_log])
        
      
        

          
          
                  #check to see if user is logging effort for unregistered courses
        
      
        

          
          
                  course_error_msg = @effort_log.validate_effort_against_registered_courses()
        
      
        

          
          
                  flash[:notice] = 'EffortLog was successfully updated.'
        
      
        

          
          
                  if (course_error_msg!="")
        
      
        

          
          
                    flash[:error] = 'You are not on a team in the following course(s)<br/>' + course_error_msg
        
      
        

          
          
                  end
        
      
        

          
          
                  format.html { redirect_to(edit_effort_log_url) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render "edit" }
        
      
        

          
          
                  format.xml { render :xml => @effort_log.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /effort_logs/1
        
      
        

          
          
            # DELETE /effort_logs/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @effort_log = EffortLog.find(params[:id])
        
      
        

          
          
              @effort_log.destroy
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { redirect_to(effort_logs_url) }
        
      
        

          
          
                format.xml { head :ok }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def effort_for_unregistered_courses
        
      
        

          
          
              @error_effort_logs_users = EffortLog.users_with_effort_against_unregistered_courses()
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html
        
      
        

          
          
                format.xml { render :xml => @error_effort_logs_users }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #Typically an ajax call
        
      
        

          1
          
            def new_effort_log_line_item
        
      
        

          
          
              setup_required_datastructures(Date.today.cwyear, Date.today.cweek)
        
      
        

          
          
              @effort_log_line_item = EffortLogLineItem.new
        
      
        

          
          
              @effort_log_line_item.effort_log_id = params[:effort_log_id]
        
      
        

          
          
              @effort_log_line_item.save
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def setup_required_datastructures(year, week_number)
        
      
        

          
          
              @day_labels = [1, 2, 3, 4, 5, 6, 7].collect do |day|
        
      
        

          
          
                Date.commercial(year, week_number, day).strftime "%b %d" # Jul 01
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @courses = Course.where(:year => Date.today.cwyear, :semester => AcademicCalendar.current_semester())
        
      
        

          
          
          
        
      
        

          
          
              @task_types = TaskType.where(:is_student => true)
        
      
        

          
          
          
        
      
        

          
          
              @today_column = which_column_is_today(year, week_number)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def which_column_is_today year, week_number
        
      
        

          
          
              column = "none"
        
      
        

          
          
              [1, 2, 3, 4, 5, 6, 7].collect do |day|
        
      
        

          
          
                column = day if Date.commercial(year, week_number, day) == Date.today
        
      
        

          
          
              end
        
      
        

          
          
              return column
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def recent_foundations_or_course
        
      
        

          
          
          #    name = "Foundations"
        
      
        

          
          
          #    recent_foundations = Course.find :first, :conditions =>  ["name like ?", "%" + name + "%"], :order => "year DESC"
        
      
        

          
          
          #    if !recent_foundations.nil? 
        
      
        

          
          
          #      return recent_foundations
        
      
        

          
          
          #    end
        
      
        

          
          
              Course.order("id DESC").first
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class EffortReportsController < ApplicationController
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv', :only => [:index, :show, :campus_semester, :campus_week, :course]
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          1
          
            class PanelState
        
      
        

          1
          
              attr_accessor :year, :week_number, :course_id, :date
        
      
        

          
          
            end
        
      
        

          1
          
            class SemesterPanel
        
      
        

          1
          
              attr_accessor :program, :track, :graduation_year, :is_part_time, :person_id, :course_id, :semester, :year
        
      
        

          
          
          
        
      
        

          1
          
              def generate_sql(just_student = nil)
        
      
        

          
          
          
        
      
        

          
          
                if (self.course_id.blank?)
        
      
        

          
          
                  sql_statement = "select distinct el.week_number, el.sum as student_effort, el.user_id "
        
      
        

          
          
                else
        
      
        

          
          
                  sql_statement = "select el.week_number, e.sum as student_effort, el.user_id "
        
      
        

          
          
                end
        
      
        

          
          
                sql_statement = sql_statement + "from effort_log_line_items e, effort_logs el,courses c, users u
        
      
        

          
          
                where e.sum>0 and e.course_id=c.id and e.effort_log_id=el.id and el.user_id= u.id and el.year=c.year"
        
      
        

          
          
                sql_statement = sql_statement + " AND el.year=#{self.year}"
        
      
        

          
          
                sql_statement = sql_statement + " and e.course_id=#{self.course_id}" unless self.course_id.blank?
        
      
        

          
          
                sql_statement = sql_statement + " and c.semester='#{self.semester}'"
        
      
        

          
          
                sql_statement = sql_statement + " and u.graduation_year='#{self.graduation_year}'" unless self.graduation_year.blank?
        
      
        

          
          
                sql_statement = sql_statement + " and u.masters_program='#{self.program}'" unless self.program.blank?
        
      
        

          
          
                sql_statement = sql_statement + " and u.masters_track='#{self.track}'" unless self.track.blank?
        
      
        

          
          
                case self.is_part_time
        
      
        

          
          
                  when "PT"
        
      
        

          
          
                    sql_statement = sql_statement + " and u.is_part_time is true"
        
      
        

          
          
                  when "FT"
        
      
        

          
          
                    sql_statement = sql_statement + " and u.is_part_time is false"
        
      
        

          
          
                end
        
      
        

          
          
                sql_statement = sql_statement + " and el.user_id=#{self.person_id}" if just_student && !self.person_id.blank?
        
      
        

          
          
          
        
      
        

          
          
                sql_statement = sql_statement + " order by el.week_number"
        
      
        

          
          
                return sql_statement
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_course_data(year, week_number, course_id)
        
      
        

          
          
              effort_logs = EffortLog.find_by_sql("select task_type_id, t.name, e.sum as student_effort from effort_log_line_items e,effort_logs el,task_types t where e.sum>0 and e.task_type_id=t.id and e.effort_log_id=el.id AND el.year=#{year} and el.week_number=#{week_number} AND e.course_id=#{course_id} order by task_type_id;")
        
      
        

          
          
          
        
      
        

          
          
              task_type_id_to_value_array_hash = {}
        
      
        

          
          
              effort_logs.each do |effort_log|
        
      
        

          
          
                key = effort_log.task_type_id
        
      
        

          
          
                value = effort_log.student_effort.to_f
        
      
        

          
          
                task_type_id_to_value_array_hash[key] = [] if task_type_id_to_value_array_hash[key].nil?
        
      
        

          
          
                task_type_id_to_value_array_hash[key] << value
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              values_array = []
        
      
        

          
          
              task_type_id_to_value_array_hash.each do |task_type_id, values|
        
      
        

          
          
                values_array << ([TaskType.find(task_type_id).name] + course_ranges_array(values))
        
      
        

          
          
              end
        
      
        

          
          
              return values_array
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def get_campus_week_data(year, week_number)
        
      
        

          
          
              effort_logs = EffortLog.where("week_number=? AND year=? AND sum>0", week_number.to_i, year.to_i)
        
      
        

          
          
          
        
      
        

          
          
              course_id_to_value_array_hash = {}
        
      
        

          
          
              effort_logs.each do |effort_log|
        
      
        

          
          
                course_to_person_hash = {}
        
      
        

          
          
                effort_log.effort_log_line_items.each do |line_item|
        
      
        

          
          
                  unless line_item.course_id == nil
        
      
        

          
          
                    course_to_person_hash[line_item.course_id] = 0 if course_to_person_hash[line_item.course_id].nil?
        
      
        

          
          
                    course_to_person_hash[line_item.course_id] += line_item.sum
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                course_to_person_hash.each do |course_id, sum|
        
      
        

          
          
                  course_id_to_value_array_hash[course_id] = [] if course_id_to_value_array_hash[course_id].nil?
        
      
        

          
          
                  course_id_to_value_array_hash[course_id] << sum
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              values_array = []
        
      
        

          
          
              course_id_to_value_array_hash.each do |course_id, values|
        
      
        

          
          
                values_array << ([Course.find_by_id(course_id).short_or_full_name] + course_ranges_array(values))
        
      
        

          
          
              end
        
      
        

          
          
              return values_array
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def get_campus_semester_data(panel)
        
      
        

          
          
              logger.debug panel.generate_sql()
        
      
        

          
          
          
        
      
        

          
          
              effort_logs = EffortLog.find_by_sql(panel.generate_sql())
        
      
        

          
          
          
        
      
        

          
          
              #The data we get is not sorted by week number and it is indexed by the commercial week of the year
        
      
        

          
          
              #At the beginning of a semester we want to show all the weeks in a semester
        
      
        

          
          
              #So we need to do a little calculation to figure out which week to start and end.
        
      
        

          
          
          
        
      
        

          
          
              #The code is not adding multiple entries per student together. Ie meetings and working on deliverables for a course
        
      
        

          
          
          
        
      
        

          
          
              unless effort_logs.blank?
        
      
        

          
          
                first_dataset_week_number = effort_logs.first.week_number
        
      
        

          
          
                last_dataset_week_number = effort_logs.last.week_number
        
      
        

          
          
                weeks_in_semester = 15
        
      
        

          
          
                weeks_in_report = [weeks_in_semester, (last_dataset_week_number - first_dataset_week_number + 1)].max
        
      
        

          
          
              else
        
      
        

          
          
                weeks_in_report = 15
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              # When the view is for only one course, a student will have logged effort for different types (meetings, deliverable)
        
      
        

          
          
              # Each of these is a row in the returnset, so we need to add up all the effort the student did for that course for
        
      
        

          
          
              # a given week
        
      
        

          
          
              student_effort_accumulator = {}
        
      
        

          
          
              effort_logs.each do |effort_log|
        
      
        

          
          
                key = [effort_log.week_number - first_dataset_week_number, effort_log.user_id]
        
      
        

          
          
                value = effort_log.student_effort.to_f
        
      
        

          
          
                if student_effort_accumulator[key].nil?
        
      
        

          
          
                  student_effort_accumulator[key] = value
        
      
        

          
          
                else
        
      
        

          
          
                  student_effort_accumulator[key] = student_effort_accumulator[key] + value
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              week_number_to_value_array_array = []
        
      
        

          
          
              person_hours = []
        
      
        

          
          
              weeks_in_report.times do |i|
        
      
        

          
          
                week_number_to_value_array_array[i] = []
        
      
        

          
          
                person_hours[i] = 0
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              student_effort_accumulator.each do |array, hours|
        
      
        

          
          
                key = array[0] #week_number
        
      
        

          
          
                value = hours
        
      
        

          
          
                week_number_to_value_array_array[key] = [] if week_number_to_value_array_array[key].nil?
        
      
        

          
          
                week_number_to_value_array_array[key] << value
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              #Determine the effort for a particular, selected student
        
      
        

          
          
              unless panel.person_id.blank?
        
      
        

          
          
                a = panel.person_id
        
      
        

          
          
                student_effort_accumulator.each do |array, hours|
        
      
        

          
          
                  week_number = array[0]
        
      
        

          
          
                  person_id = array[1]
        
      
        

          
          
                  person_hours[week_number] = hours if panel.person_id == person_id
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              values_array = []
        
      
        

          
          
              week_number_to_value_array_array.each_index do |week_number|
        
      
        

          
          
                values = week_number_to_value_array_array[week_number]
        
      
        

          
          
                unless panel.person_id.blank?
        
      
        

          
          
                  values_array << ([week_number + 1] + course_ranges_array(values) + [person_hours[week_number]])
        
      
        

          
          
                else
        
      
        

          
          
                  values_array << ([week_number + 1] + course_ranges_array(values))
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              return values_array
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          #  def box_chart_helper(reports, multiplier)
        
      
        

          
          
          ##        return "-1,"+ values.map{|v| (v ? "%.2f" % (v*multiplier):0)}.join(",") + ",-1"
        
      
        

          
          
          #    puts "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
        
      
        

          
          
          #    puts reports.values.join(",")
        
      
        

          
          
          #    puts reports.keys.join(",")
        
      
        

          
          
          #    str = "-1,"
        
      
        

          
          
          #    reports.keys.sort.each do |key|
        
      
        

          
          
          #      v = reports[key]
        
      
        

          
          
          #      #puts "LENNNNNNNNNNNN %d" % v.length
        
      
        

          
          
          #      if !v.nil?
        
      
        

          
          
          #        puts v
        
      
        

          
          
          #        #str = str + (!v.nil? ? ("%.2f" % (v*multiplier)) : 0.0).to_s  + ","
        
      
        

          
          
          #        str = str + "%.2f" % (v*multiplier) + ","
        
      
        

          
          
          #      else
        
      
        

          
          
          #        puts "=EMPTY="
        
      
        

          
          
          #        str = str + "0,"
        
      
        

          
          
          #      end
        
      
        

          
          
          #    end
        
      
        

          
          
          #    str += "-1"
        
      
        

          
          
          #    return str
        
      
        

          
          
          #  end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def generate_google_box_chart(title, reports)
        
      
        

          
          
              title_str = title.gsub(' ', '+')
        
      
        

          
          
          
        
      
        

          
          
              # Datastructure of the reports
        
      
        

          
          
              # array: [course_name, min, 25, median, 75, max]
        
      
        

          
          
              # array: [course_name, min, 25, median, 75, max, student_data] #used in campus semester view
        
      
        

          
          
          
        
      
        

          
          
              if reports && reports.size > 0
        
      
        

          
          
                max_value = reports.collect { |r| r[5] }.max
        
      
        

          
          
          
        
      
        

          
          
                multiplier = 100.0/(max_value)
        
      
        

          
          
                multiplier = 1 if max_value <= 0.0
        
      
        

          
          
          
        
      
        

          
          
                minimums_str = "-1," + reports.collect { |r| "%.2f"%(r[1]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                lower25_str = "-1," + reports.collect { |r| "%.2f"%(r[2]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                medians_str = "-1," + reports.collect { |r| "%.2f"%(r[3]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                upper25_str = "-1," + reports.collect { |r| "%.2f"%(r[4]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                maximums_str = "-1," + reports.collect { |r| "%.2f"%(r[5]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                if reports.first[6].blank?
        
      
        

          
          
                  outliers_str = ""
        
      
        

          
          
                else
        
      
        

          
          
                  outliers_str = "|-1," + reports.collect { |r| "%.2f"%(r[6]*multiplier) }.join(",")+",-1"
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                labels_str = "|"+reports.collect { |r| r[0] }.join("|")+"|"
        
      
        

          
          
          
        
      
        

          
          
                url = "http://chart.apis.google.com/chart?chtt="+title_str+"&chxt=x,y&chs=700x400&cht=lc&chd=t0:" +
        
      
        

          
          
                    minimums_str + "|" + lower25_str + "|" + upper25_str + "|" + maximums_str + "|" + medians_str + outliers_str +
        
      
        

          
          
                    "&chl=" + labels_str + #get course_id and course_name from DB
        
      
        

          
          
                    "&chm=F,FF9900,0,-1,25|H,0CBF0B,0,-1,1:10|H,000000,4,-1,1:25|H,0000FF,3,-1,1:10" +
        
      
        

          
          
                    "|o,FF0000,5,-1,7|o,FF0000,6,-1,7" +
        
      
        

          
          
                    "&chxr=1,0," + (max_value).to_s
        
      
        

          
          
                return url
        
      
        

          
          
              else
        
      
        

          
          
                return "http://chart.apis.google.com/chart?chtt="+ title_str+ "&chxt=x,y&chs=700x400&cht=lc&chd=t0:-1,0,0,0,-1|-1,0,0,0,-1|-1,0,0,0,-1|-1,0,0,0,-1|-1,0,0,0,-1&chm=F,FF9900,0,-1,25|H,0CBF0B,0,-1,1:10|H,000000,4,-1,1:25|H,0000FF,3,-1,1:10&chxr=1,0,15"
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def determine_panel_state
        
      
        

          
          
              if params[:panel_state]
        
      
        

          
          
                @panel_state = PanelState.new
        
      
        

          
          
                @panel_state.year = params[:panel_state][:year]
        
      
        

          
          
                @panel_state.week_number = params[:panel_state][:week_number]
        
      
        

          
          
                @panel_state.date = params[:panel_state][:date]
        
      
        

          
          
                logger.debug(params[:panel_state][:date])
        
      
        

          
          
                if !@panel_state.date.blank?
        
      
        

          
          
                  panel_date = Date.parse(@panel_state.date)
        
      
        

          
          
                  @panel_state.year = panel_date.cwyear
        
      
        

          
          
                  @panel_state.week_number = panel_date.cweek
        
      
        

          
          
          
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                @panel_state = PanelState.new
        
      
        

          
          
                @panel_state.year = Date.today.cwyear
        
      
        

          
          
                @panel_state.week_number = Date.today.cweek - 1
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def campus_semester
        
      
        

          
          
              if params[:semester_panel]
        
      
        

          
          
                @semester_panel = SemesterPanel.new
        
      
        

          
          
                @semester_panel.program = params[:semester_panel][:program]
        
      
        

          
          
                @semester_panel.track = params[:semester_panel][:track]
        
      
        

          
          
                @semester_panel.graduation_year = params[:semester_panel][:graduation_year]
        
      
        

          
          
                @semester_panel.is_part_time = params[:semester_panel][:is_part_time]
        
      
        

          
          
                @semester_panel.person_id = params[:semester_panel][:person_id].to_i unless params[:semester_panel][:person_id].blank?
        
      
        

          
          
                @semester_panel.course_id = params[:semester_panel][:course_id].to_i unless params[:semester_panel][:course_id].blank?
        
      
        

          
          
                @semester_panel.semester = params[:semester_panel][:semester]
        
      
        

          
          
                @semester_panel.year = params[:semester_panel][:year]
        
      
        

          
          
              else
        
      
        

          
          
                @semester_panel = SemesterPanel.new
        
      
        

          
          
                @semester_panel.program = current_user.is_student ? current_user.masters_program : "SE"
        
      
        

          
          
                @semester_panel.track = ""
        
      
        

          
          
                @semester_panel.graduation_year = ""
        
      
        

          
          
                @semester_panel.is_part_time = current_user.is_student && !current_user.is_part_time ? "FT" : "PT"
        
      
        

          
          
                @semester_panel.person_id = current_user.is_student ? current_user.id : ""
        
      
        

          
          
                @semester_panel.course_id = ""
        
      
        

          
          
                @semester_panel.semester = AcademicCalendar.current_semester
        
      
        

          
          
                @semester_panel.year = Date.today.cwyear
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if current_user.is_staff || current_user.is_admin
        
      
        

          
          
                @students = Person.where(:is_student => true).order("first_name ASC, last_name ASC")
        
      
        

          
          
              else
        
      
        

          
          
                @students = [current_user]
        
      
        

          
          
              end
        
      
        

          
          
              @courses = Course.where(:semester => @semester_panel.semester, :year => @semester_panel.year).order("name ASC")
        
      
        

          
          
              @programs = []
        
      
        

          
          
          
        
      
        

          
          
              ActiveRecord::Base.connection.execute("SELECT distinct masters_program FROM users u;").each do |result|
        
      
        

          
          
                @programs << result["masters_program"]
        
      
        

          
          
              end
        
      
        

          
          
              @tracks = []
        
      
        

          
          
              ActiveRecord::Base.connection.execute("SELECT distinct masters_track FROM users u;").each do |result|
        
      
        

          
          
                @tracks << result["masters_track"]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              title = "Campus View - " + @semester_panel.semester + " " + @semester_panel.year.to_s
        
      
        

          
          
              reports = get_campus_semester_data(@semester_panel)
        
      
        

          
          
              @chart_url = generate_google_box_chart(title, reports)
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if params[:layout]
        
      
        

          
          
                  format.html { render :layout => false } # index.html.erb
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :layout => "cmu_sv" } # index.html.erb
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def campus_week
        
      
        

          
          
              determine_panel_state()
        
      
        

          
          
              title = "Campus View - Week " + @panel_state.week_number.to_s + " of " + @panel_state.year.to_s
        
      
        

          
          
              course_data = get_campus_week_data(@panel_state.year, @panel_state.week_number)
        
      
        

          
          
              @chart_url = generate_google_box_chart(title, course_data)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def course
        
      
        

          
          
              determine_panel_state()
        
      
        

          
          
              if params[:panel_state]
        
      
        

          
          
                @panel_state.course_id = params[:panel_state][:course_id]
        
      
        

          
          
              else
        
      
        

          
          
                @panel_state.course_id = params[:course_id]
        
      
        

          
          
          
        
      
        

          
          
                if @panel_state.year.blank?
        
      
        

          
          
                  @panel_state.year = Date.today.cwyear
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                if @panel_state.week_number.blank?
        
      
        

          
          
                  @panel_state.week_number = Date.today.cweek - 1
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
              end
        
      
        

          
          
              puts "PAREMETERS: #{@panel_state.year}, #{@panel_state.week_number}, #{params[:course_id]}"
        
      
        

          
          
              @chart_url = generate_course_chart(@panel_state.year, @panel_state.week_number, @panel_state.course_id)
        
      
        

          
          
          
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def generate_course_chart(year, week_number, course_id)
        
      
        

          
          
              course = Course.where(:id => course_id).first
        
      
        

          
          
              if course
        
      
        

          
          
                title = course.name
        
      
        

          
          
              else
        
      
        

          
          
                title = "Course Does Not Exist"
        
      
        

          
          
              end
        
      
        

          
          
              reports = get_course_data(year, week_number, course_id)
        
      
        

          
          
              return generate_google_box_chart(title, reports)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show_week
        
      
        

          
          
              if params[:week]
        
      
        

          
          
                @week_number = params[:week].to_i
        
      
        

          
          
              else
        
      
        

          
          
                @week_number = Date.today.cweek
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if @week_number <= 0 then
        
      
        

          
          
                @week_number = 1
        
      
        

          
          
              end
        
      
        

          
          
              if @week_number >52 then
        
      
        

          
          
                @week_number = @week_number - 52
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @next_week_number = @week_number + 1
        
      
        

          
          
              @prev_week_number = @week_number - 1
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          #  def load_google_chart
        
      
        

          
          
          #
        
      
        

          
          
          #    GoogleChart::BoxChart.new('800x200', "Box Chart") do |bc|
        
      
        

          
          
          #      bc.data "s1",[-1,5,10,7,12,-1]
        
      
        

          
          
          #      bc.data "s2",[-1,25,30,27,24,-1]
        
      
        

          
          
          #      bc.data "s3",[-1,40,45,47,39,-1]
        
      
        

          
          
          #      bc.data "s4",[-1,55,63,59,80,-1]
        
      
        

          
          
          #      bc.data "s5",[-1,30,40,35,30,-1]
        
      
        

          
          
          #      bc.data "s6",[-1,-1,5,70,90,-1]
        
      
        

          
          
          #      bc.data "s7",[-1,-1,-1,80,5,-1]
        
      
        

          
          
          #      bc.data_encoding = :text
        
      
        

          
          
          #      @chart = bc.to_url(:chm => "F,FF9900,0,1:4,40|H,0CBF0B,0,1:4,1:20|H,000000,4,1:4,1:40|H,0000FF,3,1:4,1:20|o,FF0000,5,-1,7|o,FF0000,6,-1,7")
        
      
        

          
          
          #    end
        
      
        

          
          
          #
        
      
        

          
          
          #
        
      
        

          
          
          #  end
        
      
        

          
          
          
        
      
        

          1
          
            def raw_data
        
      
        

          
          
              if !(current_user.is_admin? || current_user.is_staff?)
        
      
        

          
          
                flash[:error] = 'You don' 't have permissions to view this data.'
        
      
        

          
          
                redirect_to(effort_reports_url)
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              @report_lines = EffortLog.find_by_sql(["SELECT effort_logs.year, effort_logs.week_number, users.human_name, task_types.name, effort_log_line_items.sum, effort_log_line_items.course_id FROM effort_log_line_items inner join effort_logs on effort_log_line_items.effort_log_id = effort_logs.id inner join users on users.id = user_id inner join task_types on task_type_id = task_types.id where course_id = ?  order by week_number ", params[:id]])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def course_table
        
      
        

          
          
              if !(current_user.is_admin? || current_user.is_staff?)
        
      
        

          
          
                flash[:error] = 'You don' 't have permissions to view this data.'
        
      
        

          
          
                redirect_to(effort_reports_url)
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              @course = Course.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              #given the course id, determine the start week and the end week of the semester
        
      
        

          
          
          
        
      
        

          
          
              @report_header = ["Team", "Person"]
        
      
        

          
          
              (1..@course.course_length).each do |week|
        
      
        

          
          
                @report_header << "Wk #{week} "
        
      
        

          
          
              end
        
      
        

          
          
              #    @course.course_length.times do @report_header << "Wk  "  end
        
      
        

          
          
          
        
      
        

          
          
              @report_lines = []
        
      
        

          
          
          
        
      
        

          
          
              blank_line = Array.new(@course.course_length, "-")
        
      
        

          
          
              min_effort = Array.new(@course.course_length, 100)
        
      
        

          
          
              max_effort = Array.new(@course.course_length, 0)
        
      
        

          
          
              total_effort = Array.new(@course.course_length, 0)
        
      
        

          
          
              count_effort = Array.new(@course.course_length, 0)
        
      
        

          
          
              average_effort = Array.new(@course.course_length, 0)
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              @course.teams.each do |team|
        
      
        

          
          
                team.members.each do |user|
        
      
        

          
          
                  person_result = report_person_effort_for_course(user, @course)
        
      
        

          
          
                  @report_lines << {:team_name => team.name, :person_name => user.human_name, :effort => person_result}
        
      
        

          
          
                  min_effort = update_min(min_effort, person_result)
        
      
        

          
          
                  max_effort = update_max(max_effort, person_result)
        
      
        

          
          
                  total_effort = update_total(total_effort, person_result)
        
      
        

          
          
                  count_effort = update_count(count_effort, person_result)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              update_average(average_effort, total_effort, count_effort)
        
      
        

          
          
              @report_lines << {:team_name => "", :person_name => "", :effort => blank_line}
        
      
        

          
          
              @report_lines << {:team_name => "Summary", :person_name => "Min", :effort => min_effort}
        
      
        

          
          
              @report_lines << {:team_name => "Summary", :person_name => "Avg", :effort => average_effort}
        
      
        

          
          
              @report_lines << {:team_name => "Summary", :person_name => "Max", :effort => max_effort}
        
      
        

          
          
              @report_lines << {:team_name => "", :person_name => "", :effort => blank_line}
        
      
        

          
          
              @report_lines << {:team_name => "Summary", :person_name => "Total", :effort => total_effort}
        
      
        

          
          
              @report_lines << {:team_name => "Summary", :person_name => "Count", :effort => count_effort}
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # helper method for course_table
        
      
        

          1
          
            def update_max(max_effort, person_result)
        
      
        

          
          
              max_effort.each_index { |i| max_effort[i] = person_result[i] if person_result[i] > max_effort[i] }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_min(min_effort, person_result)
        
      
        

          
          
              min_effort.each_index { |i| min_effort[i] = person_result[i] if person_result[i] < min_effort[i] && person_result[i] > 0 }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_total(total_effort, person_result)
        
      
        

          
          
              total_effort.each_index { |i| total_effort[i] += person_result[i] }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_count(count_effort, person_result)
        
      
        

          
          
              count_effort.each_index { |i| count_effort[i] += 1 if person_result[i] != 0 }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_average(average_effort, total_effort, count_effort)
        
      
        

          
          
              average_effort.each_index { |i| average_effort[i] = total_effort[i] / count_effort[i] unless count_effort[i] == 0 }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # helper method for course_table
        
      
        

          1
          
            def report_person_effort_for_course(person, course)
        
      
        

          
          
              person_effort_log_lines = EffortLog.find_by_sql(["SELECT effort_logs.week_number, effort_log_line_items.sum  FROM effort_log_line_items inner join effort_logs on effort_log_line_items.effort_log_id = effort_logs.id where effort_log_line_items.course_id = ? and effort_logs.user_id = ? order by effort_logs.week_number", course.id, person.id])
        
      
        

          
          
          
        
      
        

          
          
              person_result = []
        
      
        

          
          
              @course.course_length.times do
        
      
        

          
          
                person_result << 0
        
      
        

          
          
              end
        
      
        

          
          
              if !person_effort_log_lines.nil? && person_effort_log_lines.size != 0 then
        
      
        

          
          
                person_effort_log_lines.each do |line|
        
      
        

          
          
                  week = line.week_number.to_i
        
      
        

          
          
                  if week >= @course.course_start && week <= @course.course_end then
        
      
        

          
          
                    person_result[week - @course.course_start + 0] += line.sum.to_i #add two to skip the team and person label at the front of the array
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
              end
        
      
        

          
          
              return person_result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def course_ranges_array(data_set) # data_set is an array of Numeric objects
        
      
        

          
          
              return [0, 0, 0, 0, 0] if data_set.blank?
        
      
        

          
          
              data_set = data_set.sort
        
      
        

          
          
              maximum = data_set.max
        
      
        

          
          
              minimum = data_set.min
        
      
        

          
          
              median = median(data_set)
        
      
        

          
          
              if data_set.count % 2 == 1
        
      
        

          
          
                lower25 = median(data_set[0..((data_set.count / 2).ceil)], 0.25)
        
      
        

          
          
                upper25 = median(data_set[((data_set.count / 2).floor)..-1], 0.75)
        
      
        

          
          
              else
        
      
        

          
          
                lower25 = median(data_set[0...(1 + data_set.count / 2)], 0.25)
        
      
        

          
          
                upper25 = median(data_set[(-1 + data_set.count / 2)..-1], 0.75)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              [minimum, lower25, median, upper25, maximum]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def median(data_set, pct = 0.5)
        
      
        

          
          
              middle = (data_set.count + 1)/2.0
        
      
        

          
          
              middle -= 1 # convert from set index to array index (count from 0)
        
      
        

          
          
              if data_set.nil? or data_set.count == 0
        
      
        

          
          
                nil
        
      
        

          
          
              elsif data_set.count == 1
        
      
        

          
          
                data_set[0]
        
      
        

          
          
              elsif data_set.count % 2 == 1
        
      
        

          
          
                data_set[middle.floor]
        
      
        

          
          
              else
        
      
        

          
          
                data_set[middle.floor] + (pct * (data_set[middle.ceil] - data_set[middle.floor]))
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class GenericAjaxController < ApplicationController
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          1
          
            def update_model_with_value
        
      
        

          
          
              model_name = params[:model]
        
      
        

          
          
              id = params[:id]
        
      
        

          
          
              attribute = params[:attribute]
        
      
        

          
          
              update_value = params[:value]
        
      
        

          
          
          
        
      
        

          
          
          # This is an example of what we are doing for an input of User, 1, course_tools_view, "links"
        
      
        

          
          
          #    instance = "User".constantize.find(1)
        
      
        

          
          
          #    instance.course_tools_view = "links"
        
      
        

          
          
          
        
      
        

          
          
              model = model_name.constantize
        
      
        

          
          
              instance = model.find_by_id(id)
        
      
        

          
          
              if (instance.nil?)
        
      
        

          
          
                return render :text => "#{model_name} does not have a row with an id of #{id}"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              unless instance.attributes.has_key? attribute
        
      
        

          
          
                return render :text => "#{model_name} does not have the attribute #{attribute}"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              unless can? :update, instance
        
      
        

          
          
                return render :text => "Do not have permission to modify #{model_name}"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              result = instance.update_attribute(attribute, update_value)
        
      
        

          
          
          
        
      
        

          
          
              if result
        
      
        

          
          
                return render :text => "Success"
        
      
        

          
          
              else
        
      
        

          
          
                return render :text => "Failure on update_attribute"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class GradesController < ApplicationController
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :get_course
        
      
        

          1
          
            before_filter :render_grade_book_menu
        
      
        

          1
          
            before_filter :validate_permission, :except => [:student_deliverables_and_grades_for_course]
        
      
        

          1
          
            before_filter :get_team_assignment, :only => [:index, :student_deliverables_and_grades_for_course]
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            def get_course
        
      
        

          
          
              @course=Course.find(params[:course_id])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def render_grade_book_menu
        
      
        

          
          
              @is_in_grade_book = true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def validate_permission
        
      
        

          
          
              unless (current_user.is_admin? || @course.faculty.include?(current_user))
        
      
        

          
          
                has_permissions_or_redirect(:admin, root_path)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_team_assignment
        
      
        

          
          
              @team_assignment = {}
        
      
        

          
          
              @course.teams.each do |t|
        
      
        

          
          
                t.members.each do |m|
        
      
        

          
          
                  @team_assignment[m.id] = t
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              if @course.grading_rule.nil?
        
      
        

          
          
                flash[:error] = I18n.t(:no_grading_rule_for_course)
        
      
        

          
          
                redirect_to course_path(@course) and return
        
      
        

          
          
              end
        
      
        

          
          
              if @course.grading_rule.default_values?
        
      
        

          
          
                flash.now[:error] = I18n.t(:default_grading_rule_for_course)
        
      
        

          
          
              end
        
      
        

          
          
              @no_pad = true
        
      
        

          
          
              @students = @course.registered_students_or_on_teams
        
      
        

          
          
              @assignments = @course.assignments
        
      
        

          
          
              @grades = {}
        
      
        

          
          
              @students.each do |student|
        
      
        

          
          
                @grades[student] = Grade.get_grades_for_student_per_course(@course, student)
        
      
        

          
          
              end
        
      
        

          
          
              render
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def student_deliverables_and_grades_for_course
        
      
        

          
          
              @course = Course.find(params[:course_id])
        
      
        

          
          
              if (params[:user_id])
        
      
        

          
          
                @user = User.find_by_param(params[:user_id])
        
      
        

          
          
              else
        
      
        

          
          
                @user = current_user
        
      
        

          
          
              end
        
      
        

          
          
              if (current_user.id != @user.id)
        
      
        

          
          
                unless (@course.faculty.include?(current_user))||(current_user.is_admin?)
        
      
        

          
          
                  flash[:error] = I18n.t(:not_your_deliverable)
        
      
        

          
          
                  redirect_to root_path and return
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              @assignments = @course.assignments
        
      
        

          
          
              @grades = {}
        
      
        

          
          
              @grades[@user] = Grade.get_grades_for_student_per_course(@course, @user)
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html { render :action => "student_deliverables" }
        
      
        

          
          
                format.xml { render :xml => @assignments }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def post_drafted_and_send #and send email
        
      
        

          
          
              grades = params["grades"]
        
      
        

          
          
              faculty_email = nil
        
      
        

          
          
              if params[:send_copy_to_myself] == "1"
        
      
        

          
          
                faculty_email = current_user.email
        
      
        

          
          
              end
        
      
        

          
          
              Grade.mail_drafted_grade(@course.id, request.host_with_port, faculty_email)
        
      
        

          
          
              render :json => ({"message" => "true"})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def save
        
      
        

          
          
              grades = params["grades"]
        
      
        

          
          
              Grade.give_grades(grades, current_user.id)
        
      
        

          
          
              render :json => ({"message" => "true"})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def send_final_grade
        
      
        

          
          
              grades = params["grades"]
        
      
        

          
          
              faculty_email = nil
        
      
        

          
          
              if params[:send_copy_to_myself] == "1"
        
      
        

          
          
                faculty_email = current_user.email
        
      
        

          
          
              end
        
      
        

          
          
              Grade.mail_final_grade(@course.id, request.host_with_port, faculty_email)
        
      
        

          
          
              render :json => ({"message" => "true"})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def import
        
      
        

          
          
              if params[:import].nil? || params[:import][:spreadsheet].nil?
        
      
        

          
          
                flash[:error] = "please select a file to import"
        
      
        

          
          
                redirect_to course_grades_path(@course) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              temp_file_path = params[:import][:spreadsheet].path
        
      
        

          
          
              if Grade.import_grade_book_from_spreadsheet(temp_file_path, @course.id)
        
      
        

          
          
                flash[:notice] = "grade book was imported"
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = "spreadsheet format is incorrect"
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to course_grades_path(@course)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def export
        
      
        

          
          
              temp_file_path = File.expand_path("#{Rails.root}/tmp/#{Process.pid}_") + "export.xls"
        
      
        

          
          
              Grade.export_grade_book_to_spreadsheet(@course, temp_file_path)
        
      
        

          
          
              flash[:notice] = "grade book was exported to " + temp_file_path
        
      
        

          
          
              send_file(temp_file_path, :filename => "GradeBook_#{@course.name}.xls")
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class JobsController < ApplicationController
        
      
        

          1
          
            layout "cmu_sv"
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
            # GET /jobs
        
      
        

          1
          
            def index
        
      
        

          
          
              @jobs = Job.scoped
        
      
        

          
          
              @jobs = @jobs.active if params[:show_all] != "true"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /jobs/new
        
      
        

          1
          
            def new
        
      
        

          
          
              authorize! :create, Job
        
      
        

          
          
              @job = Job.new
        
      
        

          
          
              @job.supervisors << current_user
        
      
        

          
          
              @projects = SponsoredProject.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /jobs/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @job = Job.find(params[:id])
        
      
        

          
          
              authorize! :update, @job
        
      
        

          
          
              @projects = SponsoredProject.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /jobs
        
      
        

          1
          
            def create
        
      
        

          
          
              authorize! :create, Job
        
      
        

          
          
              params[:job][:supervisors_override] = params[:supervisors]
        
      
        

          
          
              params[:job][:employees_override] = params[:students]
        
      
        

          
          
              @job = Job.new(params[:job])
        
      
        

          
          
              @projects = SponsoredProject.current
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @job.save
        
      
        

          
          
                  format.html { redirect_to(jobs_path, :notice => 'Job was successfully created.') }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /jobs/1
        
      
        

          
          
            # PUT /jobs/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              params[:job][:supervisors_override] = params[:supervisors]
        
      
        

          
          
              params[:job][:employees_override] = params[:students]
        
      
        

          
          
              @job = Job.find(params[:id])
        
      
        

          
          
              authorize! :update, @job
        
      
        

          
          
              if  params[:job][:is_closed].present? && params[:job][:is_closed] == "true"
        
      
        

          
          
                notice_msg = "Job was closed."
        
      
        

          
          
              end
        
      
        

          
          
              @projects = SponsoredProject.current
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @job.update_attributes(params[:job])
        
      
        

          
          
                  format.html { redirect_to(jobs_path, :notice => notice_msg || 'Job was successfully updated.') }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "edit" }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def assignments
        
      
        

          
          
              authorize! :see_job_details, Job
        
      
        

          
          
              @jobs = Job.active
        
      
        

          
          
              @all_employees = Job.all_employees
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class MailingListsController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # GET /mailing_lists
        
      
        

          
          
            # GET /mailing_lists.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @mailing_lists = []
        
      
        

          
          
              google_apps_connection.retrieve_all_groups.each do |list|
        
      
        

          
          
                # group_name = list.group_id.split('@')[0] #ie all-students
        
      
        

          
          
                @mailing_lists << list.group_id #ie all-students@sv.cmu.edu
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html
        
      
        

          
          
                format.xml { render :xml => @mailing_lists }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
            # GET /mailing_lists/1
        
      
        

          
          
            # GET /mailing_lists/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @mailing_list = params[:id]
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          #     (group, domain) = @mailing_list.split('@')
        
      
        

          
          
          #     if(domain == "sv.cmu.edu")
        
      
        

          
          
          #        @mailing_list = group + "@west.cmu.edu"
        
      
        

          
          
          #     end
        
      
        

          
          
              @mailing_list = switch_sv_to_west(@mailing_list)
        
      
        

          
          
          
        
      
        

          
          
              @members = []
        
      
        

          
          
              google_apps_connection.retrieve_all_members(@mailing_list).each do |member|
        
      
        

          
          
                tmp = member.member_id
        
      
        

          
          
                @members << member.member_id
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @members }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            rescue GDataError => e
        
      
        

          
          
              flash[:error] = "Mailing list does not exist"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class PageAttachmentsController < ApplicationController
        
      
        

          1
          
            def update
        
      
        

          3
          
              @pa = PageAttachment.find(params[:id])
        
      
        

          3
          
              @pa.user_id = current_user.id
        
      
        

          
          
          
        
      
        

          
          
              if @pa.page.editable?(current_user)
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  if @pa.update_attributes(params[:page_attachment])
        
      
        

          
          
                    format.html { redirect_to @pa.page }
        
      
        

          
          
                  else
        
      
        

          
          
                    flash[:error] = 'Could not upload your file.'
        
      
        

          
          
                    format.html { redirect_to @pa.page }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = "You don't have permission to do that."
        
      
        

          
          
                redirect_to @pa.page
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          7
          
              @pa = PageAttachment.new params[:page_attachment]
        
      
        

          7
          
              @pa.user_id = current_user.id
        
      
        

          
          
          
        
      
        

          
          
              if @pa.page.editable?(current_user)
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  if @pa.page_attachment.present? && @pa.save
        
      
        

          
          
                    format.html { redirect_to @pa.page }
        
      
        

          
          
                  else
        
      
        

          
          
                    flash[:error] = 'Could not upload your file.'
        
      
        

          
          
                    format.html { redirect_to @pa.page }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = "You don't have permission to do that."
        
      
        

          
          
                redirect_to @pa.page
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          3
          
              @pa = PageAttachment.find(params[:id])
        
      
        

          
          
          
        
      
        

          3
          
              if @pa.page.editable?(current_user)
        
      
        

          2
          
                @pa.destroy
        
      
        

          2
          
                flash[:notice] = "Page attachment successfully deleted."
        
      
        

          
          
          
        
      
        

          2
          
                respond_to do |format|
        
      
        

          4
          
                  format.html { redirect_to @pa.page }
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          1
          
                flash[:error] = "You don't have permission to do that."
        
      
        

          1
          
                redirect_to @pa.page
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reposition
        
      
        

          
          
              order = params[:page_attachment]
        
      
        

          
          
              PageAttachment.reposition(order)
        
      
        

          
          
              render :text => order.inspect
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class PageCommentTypesController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comment_types
        
      
        

          
          
            # GET /page_comment_types.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @page_comment_types = PageCommentType.all
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comment_types/1
        
      
        

          
          
            # GET /page_comment_types/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @page_comment_type = PageCommentType.find(params[:id])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comment_types/new
        
      
        

          
          
            # GET /page_comment_types/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              if has_permissions_or_redirect(:staff, page_comment_types_url)
        
      
        

          
          
          
        
      
        

          
          
                @page_comment_type = PageCommentType.new
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comment_types/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              if has_permissions_or_redirect(:staff, page_comment_types_url)
        
      
        

          
          
                @page_comment_type = PageCommentType.find(params[:id])
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /page_comment_types
        
      
        

          
          
            # POST /page_comment_types.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              if has_permissions_or_redirect(:staff, page_comment_types_url)
        
      
        

          
          
          
        
      
        

          
          
                @page_comment_type = PageCommentType.new(params[:page_comment_type])
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  if @page_comment_type.save
        
      
        

          
          
                    flash[:notice] = 'PageCommentType was successfully created.'
        
      
        

          
          
                    format.html { redirect_to(@page_comment_type) }
        
      
        

          
          
                    format.xml { render :xml => @page_comment_type, :status => :created, :location => @page_comment_type }
        
      
        

          
          
                  else
        
      
        

          
          
                    format.html { render :action => "new" }
        
      
        

          
          
                    format.xml { render :xml => @page_comment_type.errors, :status => :unprocessable_entity }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /page_comment_types/1
        
      
        

          
          
            # PUT /page_comment_types/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              if has_permissions_or_redirect(:staff, page_comment_types_url)
        
      
        

          
          
                @page_comment_type = PageCommentType.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  if @page_comment_type.update_attributes(params[:page_comment_type])
        
      
        

          
          
                    flash[:notice] = 'PageCommentType was successfully updated.'
        
      
        

          
          
                    format.html { redirect_to(@page_comment_type) }
        
      
        

          
          
                    format.xml { head :ok }
        
      
        

          
          
                  else
        
      
        

          
          
                    format.html { render :action => "edit" }
        
      
        

          
          
                    format.xml { render :xml => @page_comment_type.errors, :status => :unprocessable_entity }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /page_comment_types/1
        
      
        

          
          
            # DELETE /page_comment_types/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              if has_permissions_or_redirect(:admin, page_comment_types_url)
        
      
        

          
          
                @page_comment_type = PageCommentType.find(params[:id])
        
      
        

          
          
                @page_comment_type.destroy
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { redirect_to(page_comment_types_url) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class PageCommentsController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          
          
          # This would happen on the page show
        
      
        

          
          
          #  def index
        
      
        

          
          
          #    page = Page.find(params[:id])
        
      
        

          
          
          #    @page_comments = PageComment.where("page_id = ? and semester = ? and year = ?", page.id, AcademicCalendar.current_semester(), Date.today.year.to_s)
        
      
        

          
          
          #    respond_to do |format|
        
      
        

          
          
          #      format.html # index.html.erb
        
      
        

          
          
          #      format.xml { render :xml => @page_comments }
        
      
        

          
          
          #    end
        
      
        

          
          
          #  end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comments/1
        
      
        

          
          
            # GET /page_comments/1.xml
        
      
        

          1
          
            def show
        
      
        

          
          
              @page_comment = PageComment.find(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # show.html.erb
        
      
        

          
          
                format.xml { render :xml => @page_comment }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comments/new
        
      
        

          
          
            # GET /page_comments/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              @page_comment = PageComment.new
        
      
        

          
          
              @page_comment.notify_me = true if current_user
        
      
        

          
          
              @types = PageCommentType.all
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @page_comment }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /page_comments/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @page_comment = PageComment.find(params[:id])
        
      
        

          
          
              @types = PageCommentType.all
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /page_comments
        
      
        

          
          
            # POST /page_comments.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              @page_comment = PageComment.new(params[:page_comment])
        
      
        

          
          
              @page_comment.user_id = current_user.id if current_user
        
      
        

          
          
              @page_comment.semester = AcademicCalendar.current_semester()
        
      
        

          
          
              @page_comment.year = Date.today.year
        
      
        

          
          
              @types = PageCommentType.all
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @page_comment.save
        
      
        

          
          
                  a = PageCommentMailer.comment_update(@page_comment, "created")
        
      
        

          
          
                  a.deliver
        
      
        

          
          
                  flash[:notice] = 'Comment was successfully created.'
        
      
        

          
          
                  format.html { redirect_to(@page_comment.url) }
        
      
        

          
          
                  format.xml { render :xml => @page_comment, :status => :created, :location => @page_comment }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @page_comment.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /page_comments/1
        
      
        

          
          
            # PUT /page_comments/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @page_comment = PageComment.find(params[:id])
        
      
        

          
          
              unless @page_comment.editable?(current_user)
        
      
        

          
          
                flash[:error] = I18n.t(:no_permission)
        
      
        

          
          
                redirect_to(@page_comment.url) and return
        
      
        

          
          
              end
        
      
        

          
          
              @types = PageCommentType.all
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @page_comment.update_attributes(params[:page_comment])
        
      
        

          
          
                  PageCommentMailer.comment_update(@page_comment, "updated").deliver
        
      
        

          
          
                  flash[:notice] = 'Comment was successfully updated.'
        
      
        

          
          
                  format.html { redirect_to(@page_comment.url) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "edit" }
        
      
        

          
          
                  format.xml { render :xml => @page_comment.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # DELETE /page_comments/1
        
      
        

          
          
            # DELETE /page_comments/1.xml
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @page_comment = PageComment.find(params[:id])
        
      
        

          
          
              if has_permissions_or_redirect(:admin, @page_comment.url)
        
      
        

          
          
                @page_comment.destroy
        
      
        

          
          
          
        
      
        

          
          
                respond_to do |format|
        
      
        

          
          
                  format.html { redirect_to(page_comments_url) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class PagesController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!, :except => [:show]
        
      
        

          
          
          
        
      
        

          
          
            #  layout 'cmu_sv_no_pad'
        
      
        

          1
          
            layout 'cmu_sv'
        
      
        

          
          
          
        
      
        

          
          
            # GET /pages
        
      
        

          
          
            # GET /pages.xml
        
      
        

          1
          
            def index
        
      
        

          
          
              @pages = Page.all
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # index.html.erb
        
      
        

          
          
                format.xml { render :xml => @pages }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def changed
        
      
        

          
          
              @pages = Page.order("updated_at DESC").all
        
      
        

          
          
              @no_pad = true
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html
        
      
        

          
          
                format.xml { render :xml => @pages }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /pages/1
        
      
        

          
          
            # GET /pages/1.xml
        
      
        

          1
          
            def show
        
      
        

          6
          
              @no_pad = true
        
      
        

          6
          
              @page = Page.find_by_url(params[:id])
        
      
        

          6
          
              @page.revert_to(params[:version].to_i) if params[:version]
        
      
        

          
          
          
        
      
        

          6
          
              if @page.blank?
        
      
        

          
          
                flash[:error] = "Page with an id of #{params[:id]} is not in this system. You may create it using the form below."
        
      
        

          
          
                redirect_to(:controller => :pages, :action => :new, :url => params[:id]) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          6
          
              if @page.visible == false
        
      
        

          
          
                flash[:error] = "This page no longer exists."
        
      
        

          
          
                redirect_to(root_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          6
          
              unless @page.viewable?(current_user)
        
      
        

          5
          
                flash[:error] = "You don't have permission to do this action."
        
      
        

          5
          
                redirect_to(root_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              @tab = params[:tab]
        
      
        

          
          
          
        
      
        

          1
          
              respond_to do |format|
        
      
        

          1
          
                format.html # show.html.erb
        
      
        

          1
          
                format.xml { render :xml => @page }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /pages/new
        
      
        

          
          
            # GET /pages/new.xml
        
      
        

          1
          
            def new
        
      
        

          
          
              @page = Page.new
        
      
        

          
          
              @page.title = params[:url].split('_').collect { |w| w.capitalize + ' ' }.join().chomp(' ') if params[:url]
        
      
        

          
          
              @page.url = params[:url]
        
      
        

          
          
              @page.course_id = params[:course_id].to_i
        
      
        

          
          
              @courses = Course.unique_course_names
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @page }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # GET /pages/1/edit
        
      
        

          1
          
            def edit
        
      
        

          
          
              @page = Page.find_by_url(params[:id])
        
      
        

          
          
              @courses = Course.unique_course_names
        
      
        

          
          
          
        
      
        

          
          
              if @page.blank?
        
      
        

          
          
                flash[:error] = "Page with an id of #{params[:id]} is not in this system."
        
      
        

          
          
                redirect_to(pages_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              unless @page.editable?(current_user)
        
      
        

          
          
                flash[:error] = "You don't have permission to do this action."
        
      
        

          
          
                redirect_to(page_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              if @page.is_someone_else_currently_editing_page(current_user) && @page.timeout_has_not_passed
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
                flash[:notice] = "#{@page.current_edit_by.human_name} started editing this page
        
      
        

          
          
                                  #{pluralize(((Time.now - @page.current_edit_started_at) / 1.minute).round, 'minute')} ago at
        
      
        

          
          
                                  #{l @page.current_edit_started_at, :format => :detailed }"
        
      
        

          
          
                redirect_to(page_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              @page.skip_version do
        
      
        

          
          
                @page.current_edit_by = current_user
        
      
        

          
          
                @page.current_edit_started_at = Time.now
        
      
        

          
          
                @page.save!
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html # new.html.erb
        
      
        

          
          
                format.xml { render :xml => @page }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def pluralize(number, text)
        
      
        

          
          
              return number.to_s+' '+text.pluralize if number != 1
        
      
        

          
          
              number.to_s+' '+text
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # POST /pages
        
      
        

          
          
            # POST /pages.xml
        
      
        

          1
          
            def create
        
      
        

          
          
              @page = Page.new(params[:page])
        
      
        

          
          
              @courses = Course.unique_course_names
        
      
        

          
          
          
        
      
        

          
          
              @page.updated_by_user_id = current_user.id if current_user
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @page.save
        
      
        

          
          
                  flash[:notice] = 'Page was successfully created.'
        
      
        

          
          
                  format.html { redirect_to(@page) }
        
      
        

          
          
                  format.xml { render :xml => @page, :status => :created, :location => @page }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :action => "new" }
        
      
        

          
          
                  format.xml { render :xml => @page.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # PUT /pages/1
        
      
        

          
          
            # PUT /pages/1.xml
        
      
        

          1
          
            def update
        
      
        

          
          
              @page = Page.find_by_url(params[:id])
        
      
        

          
          
              @courses = Course.unique_course_names
        
      
        

          
          
          
        
      
        

          
          
              unless @page.editable?(current_user)
        
      
        

          
          
                flash[:error] = "You don't have permission to do this action."
        
      
        

          
          
                redirect_to(page_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html do
        
      
        

          
          
                  update_page_edit_info(@page)
        
      
        

          
          
                  if @page.update_attributes(params[:page])
        
      
        

          
          
                    unless params[:timeout_flag].blank?
        
      
        

          
          
                      flash[:notice] = "We thought you left, so we saved your page for you."
        
      
        

          
          
                    else
        
      
        

          
          
                      flash[:notice] = 'Page was successfully updated.'
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                    redirect_to(@page)
        
      
        

          
          
                  else
        
      
        

          
          
                    render :action => "edit"
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                format.xml do
        
      
        

          
          
                  update_page_edit_info(@page)
        
      
        

          
          
                  if @page.update_attributes(params[:page])
        
      
        

          
          
                    head :ok
        
      
        

          
          
                  else
        
      
        

          
          
                    render :xml => @page.errors, :status => :unprocessable_entity
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                format.json do
        
      
        

          
          
                  # Do not bump up the version number for auto save
        
      
        

          
          
                  @page.skip_version do
        
      
        

          
          
                    if @page.update_attributes(params[:page])
        
      
        

          
          
                      render :json => {:code => "success", :message => "", :new_post_path => page_path(@page)}
        
      
        

          
          
                    else
        
      
        

          
          
                      render :json => {:code => "failed", :message => "Automatic save failed"}
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def revert
        
      
        

          
          
              @page = Page.find_by_url(params[:id])
        
      
        

          
          
          
        
      
        

          
          
              if @page.blank?
        
      
        

          
          
                flash[:error] = "Page with an id of #{params[:id]} is not in this system."
        
      
        

          
          
                redirect_to(pages_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              unless @page.editable?(current_user)
        
      
        

          
          
                flash[:error] = "You don't have permission to do this action."
        
      
        

          
          
                redirect_to(page_url) and return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @page.revert_to! params[:version].to_i
        
      
        

          
          
                  flash[:notice] = 'Page was successfully reverted.'
        
      
        

          
          
                  format.html { redirect_to(@page) }
        
      
        

          
          
                  format.xml { head :ok }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { redirect_to page_path(@page, :history => true) }
        
      
        

          
          
                  format.xml { render :xml => @page.errors, :status => :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def update_page_edit_info(page)
        
      
        

          
          
              page.updated_by_user_id = current_user.id if current_user
        
      
        

          
          
              page.current_edit_by = nil
        
      
        

          
          
              page.current_edit_started_at = nil
        
      
        

          
          
            end
        
      
        

          
          
          end